🚀 go-pugleaf

daniel@cse.ucsc.edu (Daniel R. Edelson) writes:

>There's also a problem regarding inline functions.
>Specifically, under common file-based C++ implementations, 
>the address of an inline function  can vary between
>compilation units. Thus, the requirement from
>Ansi C (Sec 3.3.9)
>	``If two pointers to function types ... both point to
>	the same function, they compare equal.''
>is false under common C++ implementations.

Actually, these implementations are correct. Inline non-member functions have
internal linkage, and thus an inline function in one compilation unit
is a different function to even a lexically identical inline function in
a different compilation unit. (Inline member functions however are a
whole different can of worms.)

Does ANSI C require that pointers to different functions
will compare unequal? If so, it is not the common C++ implementations
that are the difficulty, it is the more sophisticated C++ implementations
(such as Borland C++ with the "Smart Inlines" flag enabled) that use
smart linkers or other techniques to avoid generating multiple copies
of inline functions.

Personally I believe that the default internal linkage for inline
non-member functions was a mistake, brought about by letting the
original implementation dictate too strongly the semantics of the
language. Even if it is perhaps too late to change this, the ANSI C++
standard should definitely not require that pointers to different
functions compare unequal, because that would prevent a useful
optimization, with no real gain. It should be enough to require
that if f and g are function pointers of the same type for which
f==g, then (*f)(...) has the same effect as (*g)(...).

-- 
Fergus Henderson             fjh@munta.cs.mu.OZ.AU      
This .signature virus is a self-referential statement that is true - but 
you will only be able to consistently believe it if you copy it to your own
.signature file!