Modifying Dependent Shared Objects in Executables

Question

I am attempting to perform the following operations on ELF32 format files:
1) modify the names of the NEEDED shared objects that are referenced by an executable after the executable has been built.
2) modify the embedded SONAME of a shared object file (adding one if it does not exist) after the shared object file has been built.
3) modifying the NEEDED shared objects that are referenced in a shared object file after it has been built.
The shared objects and executables are built from third party software that we have the source code for, but we do NOT want to modify the Makefile for each third party package each time we build a new version.
Of the three items, the one that is proving the most challenging is the modification of the executable files after they have been built.
Is there either a tool that enables me to modify these fields in the shared objects as well as the executables? Is there a way that I can re-link a shared object or executable file and then specify that modifications be made to the existing SONAME and NEEDED information?
(I have attempted unsuccessfully to use the elf library on executable files. Even relatively simple operations, such as modifying the length of the dynamic string section in which the NEEDED shared object is stored breaks the executable file.)

Answer 1

Hello Tomi,
First, thank you for taking the time to write such a well
though-out suggestion.  Are you familiar
with the “LabVIEW Object-Oriented Programming: The Decisions Behind the Design”
document?  I think the reason we chose to implement a ‘by
value’ strategy, is that is more in line with the LabVIEW programming paradigm
of dataflow, and would make sense to most of our LabVIEW users.
I think your suggestion is interesting, and it does
highlight the need to think outside of the conventional LabVIEW box and look to
some of the innovative things other languages do.  However, I think we all agree that
synchronization takes careful planning and extra work for the programmer.  Even with an ‘ideal’ solution I see no way
around this.  For LabVIEW users today,
one great way to get synchronized ‘by reference’ semantics with your objects is
to use a single-element queue to pass your object.  The queue itself is passed ‘by reference’ and
is inherently synchronized!  The does
have the disadvantage of adding one more small layer of complexity to your
program, but some complexity would have to be introduced in any situation.  The other disadvantage with this is that it
is not always an intuitive way to implement your program and requires some
amount of LabVIEW knowledge before one would generally come across this
technique.
In any case, I appreciate the time and effort you put in to
your suggestion.  Please make sure that
you submit the suggestion formally through the NI Product Suggestion Center so
that it can be reviewed by some of the decision makers here.
Thanks again,
Travis M
LabVIEW R&D
National Instruments