Hiding non-API symbols in library

Question

Suppose I have a library foo which consists of the modules foo and util and has the following source tree:

foo/
    foo.c
    foo.h
    util.c
    util.h

The public API of the library is defined in foo.h and all global identifiers are properly prefixed with foo_ or util_. The module util is only used by foo. To prevent name clashes with other modules named util I want to create a (static) library in which only identifiers from module foo are visible. How can I do this?

Edit: I have searched the internet quite extensively but surprisingly this seems to be one of those unsolved problems in computer science.

Myst · Answer 1 · 2017-09-06T00:43:49.600

2

There are probably other possible approaches, but here's one:

You might consider including the file util.c within foo.c and making all the util functions / globals static. i.e.:

#include "util.c"
// ...

This works the same as *.h files, it simply ports the whole source into foo.c, nesting util.c and making all the static data available.

When I do this, I rename the file to .inc (i.e. util.c => util.inc)...

#include "util.inc"
// ...

...it's an older convention I picked up somewhere, though it might conflict with assembler files, so you'll have to use your own discretion.

EDIT

Another approach might require linker specific directives. For example, this SO answer details GNU's ld to achieve this goal. There are other approaches as well, listed in that same thread.

edited Sep 06 '17 at 00:43

answered Sep 05 '17 at 15:30

Myst

18,516
2
45
67

That's an interesting approach. However, I would prefer a solution which works at the object file level. – August Karlstrom Sep 05 '17 at 16:16
@AugustKarlstrom I can definitely understand this preference. However, I think this would be a linker specific solution. I edited my answer with details. – Myst Sep 05 '17 at 16:44
The GNU ld approach you linked to requires manually managing a file of exported symbols. I should be able to say that all symbols in util.o should be hidden. – August Karlstrom Sep 05 '17 at 17:16
@AugustKarlstrom The same thread I linked to offers some other approaches as well. However, I think the only portable approach that will work regardless of compiler or linker would end up being the `#include` approach. Personally, I target `gcc` and `clang`, so I have an easy time using non-portable features. – Myst Sep 06 '17 at 00:43

score 0 · Answer 2 · answered Sep 05 '17 at 18:03

The following is GCC-specific.

You can mark each utility function with

__attribute__((visibility ("hidden")))

which will prevent it from being linked to from another shared object.

You can apply this to a series of declarations by surrounding them with

#pragma GCC visibility push(hidden)
/* ... */
#pragma GCC visibility pop

or use -fvisibility=hidden when compiling the object, which applies to declarations without an explicit visibility (e.g. neither __attribute__((visibility)) nor #pragma GCC visibility).

score 0 · Accepted Answer · answered Sep 07 '17 at 04:51

Before each variable and function declaration in util.h, define a macro constant which renames the declared identifier by adding the library prefix foo_, for instance

#define util_x foo_util_x
extern int util_x;   

#define util_f foo_util_f
void util_f(void);

...

With these definitions in place, no other parts of the code need to be changed, and all global symbols in the object file util.o will be prefixed with foo_. This means that name collisions are less likely to occur.

Hiding non-API symbols in library

3 Answers3