Can I make some symbols only visible to other library members?

Question

Consider 3 C source files:

/* widgets.c */
void widgetTwiddle ( struct widget * w ) {
    utilityTwiddle(&w->bits, 1);
}

and

/* wombats.c */
void wombatTwiddle ( struct wombat * w ) {
    utilityTwiddle(&w->bits, 1);
}

and

/* utility.c */
void utilityTwiddle ( int * bitsPtr, int bits ) {
    *bitsPtr ^= bits;
}

which get compiled and put in a library (say, either libww.a or libww.so). Is there a way to make utilityTwiddle() visible and usable by the other two library members, but not be visible to to those who link to the library? That is, given this:

/* appl.c */
extern void utilityTwiddle ( int * bitsPtr, int bits );
int main ( void ) {
    int bits;
    utilityTwiddle(&bits, 1);
    return 0;
}

and

cc -o appl appl.c -lww

it would fail to link because utilityTwiddle() is not visible to appl.c. And, consequently appl.c would be free to define its own utilityTwiddle function or variable.

[EDIT] And hopefully obviously, we would like this to work:

/* workingappl.c */
extern void wombatTwiddle ( struct wombat * wPtr );
int main ( void ) {
    struct wombat w = { .bits = 0 };
    wombatTwiddle(&w);
    return 0;
}

This Limiting visibility of symbols when linking shared libraries seems related, but it doesn't seem to address whether the symbols suppressed are available to other library members.

[EDIT2] I have sort-of figured out a way to do it without modifying the C source. Add a map file:

/* utility.map */
{ local: *; };

and then do:

$ gcc -shared -o utility.so utility.c -fPIC -Wl,--version-script=utility.map

gives us a dynamic symbol table w/o utilityTwiddle:

$ nm -D utility.so
             w _Jv_RegisterClasses
             w __cxa_finalize
             w __gmon_start__

but it's not clear to me how to effectively go from this to building a shared library with all three source files. If I put all three source files on the command line, the symbols from all three are hidden. If there is a way to incrementally build the shared library, I could have two simple map files (one to export nothing, one to export everything). Is this doable or is the only option something like this:

/* libww.map */
{ global: list; of; all; symbols; to; export; local: *; };

and

$ gcc -shared -o libww.so *.c -fPIC -Wl,--version-script=libww.map

[EDIT3] Boy, it sure seems like this also ought to be possible without using shared libraries. If I do:

ld -r -o wboth.o widgets.o wombats.o utility.o

I can see that the linker has resolved to location of utilityTwiddle() where widgetTwiddle() and wombatTwiddle() call it:

$ objdump -d wboth.o
0000000000000000 :
   0:   be 01 00 00 00          mov    $0x1,%esi
   5:   e9 00 00 00 00          jmpq   a 
0000000000000010 :
  10:   be 01 00 00 00          mov    $0x1,%esi
  15:   e9 00 00 00 00          jmpq   1a 
0000000000000020 :
  20:   31 37                   xor    %esi,(%rdi)
  22:   c3                      retq

but utilityTwiddle remains as a symbol:

$ nm wboth.o
                 U _GLOBAL_OFFSET_TABLE_
0000000000000020 T utilityTwiddle
0000000000000000 T widgetTwiddle
0000000000000010 T wombatTwiddle

and so if you could find a way to remove that symbol, you could still successfully link against wboth.o (I have tested this by binary editing wboth.o) and it still links and runs fine:

$ nm wboth.o
                 U _GLOBAL_OFFSET_TABLE_
0000000000000000 T widgetTwiddle
0000000000000010 T wombatTwiddle
0000000000000020 T xtilityTwiddle

Can I make some symbols only visible to other library members?

Answers (1)

Related Questions