Consider these two functions:

    void foo() {}
    void bar() {}
is it guaranteed that `&amp;foo != &amp;bar`?

Similarly,

    template&lt;class T&gt; void foo() { }
is it guaranteed that `&amp;foo&lt;int&gt; != &amp;foo&lt;double&gt;`?

---

There are two linkers I know of that fold function definitions together.

MSVC aggressively COMDAT folds functions, so two functions with the same implementation can be turned into one function.  As a side effect, the two functions share the same address.  I was under the impression that this was illegal, but I cannot find where in the standard it is made illegal.

[The Gold linker](http://research.google.com/pubs/pub36912.html) also folds functions, with both a `safe` and `all` setting.  `safe` means that if a function address is taken, it is not folded, while `all` folds even if the address is taken.  So gold&#39;s fold `safe` behaves as-if functions have distinct addresses.

While folding might be unexpected, and there is code that relies on distinct (identical implementation) functions having different addresses (so it can be dangerous to fold), is it actually illegal under the current C++ standard?  (C++14 at this point)  (Naturally as-if `safe` folding is legal)


All Comdat Folding Solutions on Gang of Coders

Total of 1 Comdat Folding Solutions

Do distinct functions have distinct addresses?