10

I am writing a C (shared) library. It started out as a single translation unit, in which I could define a couple of static global variables, to be hidden from external modules.

Now that the library has grown, I want to break the module into a couple of smaller source files. The problem is that now I have two options for the mentioned globals:

  1. Have private copies at each source file and somehow sync their values via function calls - this will get very ugly very fast.

  2. Remove the static definition, so the variables are shared across all translation units using extern - but now application code that is linked against the library can access these globals, if the required declaration is made there.

So, is there a neat way for making private global variable shared across multiple, specific translation units?

Improve this question

4 Answers 4

Reset to default
10

You want the visibility attribute extension of GCC.

Practically, something like:

 #define MODULE_VISIBILITY  __attribute__ ((visibility ("hidden")))
 #define PUBLIC_VISIBILITY  __attribute__ ((visibility ("default")))

(You probably want to #ifdef the above macros, using some configuration tricks à la autoconfand other autotools; on other systems you would just have empty definitions like #define PUBLIC_VISIBILITY /*empty*/ etc...)

Then, declare a variable:

int module_var  MODULE_VISIBILITY;

or a function 

void module_function (int) MODULE_VISIBILITY;

Then you can use module_var or call module_function inside your shared library, but not outside.

See also the -fvisibility code generation option of GCC.

BTW, you could also compile your whole library with -Dsomeglobal=alongname3419a6 and use someglobal as usual; to really find it your user would need to pass the same preprocessor definition to the compiler, and you can make the name alongname3419a6 random and improbable enough to make the collision improbable.

PS. This visibility is specific to GCC (and probably to ELF shared libraries such as those on Linux). It won't work without GCC or outside of shared libraries.... so is quite Linux specific (even if some few other systems, perhaps Solaris with GCC, have it). Probably some other compilers (clang from LLVM) might support also that on Linux for shared libraries (not static ones). Actually, the real hiding (to the several compilation units of a single shared library) is done mostly by the linker (because the ELF shared libraries permit that).

Improve this answer
Sign up to request clarification or add additional context in comments.

9 Comments

What makes you think that the OP is using GCC and that code portability isn't desired?
I did tell it is a GCC extension. I added a PS repeating that.
Yes you did. I commented since I don't think that Stack Overflow should be a GCC forum, everyone seems to implicitly assume GCC nowadays.
It actually become useful enough to be supported by other compilers. And it actually is mostly implemented by the linker: the compiler only passes the attribute to the linker which does the real hiding job.
Thanks. I wasn't aware of these attributes. I do use GCC, BTW. I am not sure that I should stick to Linux private tricks with regard to this library, though.
|
5

The easiest ("old-school") solution is to simply not declare the variable in the intended public header.

Split your libraries header into "header.h" and "header-internal.h", and declare internal stuff in the latter one.

Of course, you should also take care to protect your library-global variable's name so that it doesn't collide with user code; presumably you already have a prefix that you use for the functions for this purpose.

You can also wrap the variable(s) in a struct, to make it cleaner since then only one actual symbol is globally visible.

Improve this answer

4 Comments

"You can protect code from Murphy, but never from Machiavelli."
Thanks. Surely you should not put that in the public header file, but, as I mentioned in my question, you can still access the variable with the proper declaration in your application. I try to keep variable names clear and concise, so the probability of the user defining similar names, esp. in the context of code using that library, is somewhat higher than zero. This is why I am looking to protect it. Putting them in a struct, though, is an idea I may use to further reduce this probability.
@ysap If you link your whole library into "something", that isn't raw source code, all such namespace issues will disappear and the user of your library will only have to worry about the public header.
Well, the user application IS source code (at least, this is the general case. I cannot assume the user just links precompiled objects).
2

You can obfuscate things with disguised structs, if you really want to hide the information as best as possible. e.g. in a header file,

struct data_s {
   void *v;
};

And somewhere in your source:

struct data_s data;
struct gbs {
   // declare all your globals here
} gbss;

and then:

data.v = &gbss;

You can then access all the globals via: ((struct gbs *)data.v)->

Improve this answer

2 Comments

Thanks. Basically what @unwind suggested. Obfuscating is the straight-forward solution, but makes my code uglier.
@ysap You can use macros to make it look a bit tidier. It makes things more difficult certainly, but it's a lot harder to find the global variables.
0

I know that this will not be what you literally intended, but you can leave the global variables static and divide them into multiple source files.

Copy the functions that write to the corresponding static variable in the same source file also declared static.

Declare functions that read the static variable so that external source files of the same module can read it's value.

In a way making it less global. If possible, best logic for breaking big files into smaller ones, is to make that decision based on the data.

If it is not possible to do it this way than you can bump all the global variables into one source file as static and access them from the other source files of the module by functions, making it official so if someone is manipulating your global variables at least you know how. But then it probably is better to use @unwind's method.

Improve this answer

Comments

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.