On Fri, 2006-09-15 at 13:54 -0700, Ian Lance Taylor wrote:
> Laurent GUERBY <[EMAIL PROTECTED]> writes:
> > For code sections (I assume read-only), isn't the linker always able to
> > merge identical ones? What can the compiler do better than the linker?
>
> The linker can't merge just any identical code section, it can only
> merge code sections where that is permitted. For example, consider:
>
> int foo() { return 0; }
> int bar() { return 0; }
> int quux(int (*pfn)()) { return pfn == &foo; }
>
> Compile with -ffunction-sections. If the linker merges sections, that
> program will break.
Indeed.
The compiler could merge (or mark for linker) static functions whose
address is not taken, those are safe against this use.
But by your argument, I don't see when the compiler can merge excepted
in the case I just mentionned, at least for C? (I don't know C++ enough
to understand other messages in this thread :).
On the Ada side, there are a few tricks, in particular a program naively
similar to the C program above is not portable in its use of equality:
<<
4.5.2 Relational Operators and Membership Tests
[...]
13 Two access-to-subprogram values are equal if they are the result of the
same evaluation of an Access attribute_reference, or if both are equal to the
null value of the access type. Two access-to-subprogram values are unequal if
they designate different subprograms. {unspecified [partial]} [It is
unspecified whether two access values that designate the same subprogram but
are the result of distinct evaluations of Access attribute_references are
equal or unequal.]
13.a Reason: This allows each Access attribute_reference for a subprogram
to designate a distinct "wrapper" subprogram if necessary to support
an indirect call.
>>
Now, it's not 100% clear whether subprogram that are never different in
their outcome are "different" as meant here. Generics instanciation (aka
template) can lead to the same access value for different types in
many implementation, I haven't seen a special case for those in the RM.
If you're using subprogram access as an enum type indeed your're loosing
a valuable code size optimization, may be a compile flag could be
useful.
Laurent
