3

Description :

a. Class X contains a static private data member ptr and static public function member getptr()/setptr().
In X.cpp, the ptr is set to NULL.

b. libXYZ.so (shared object) contains the object of class X (i.e libXYZ.so contains X.o).

c. libVWX.so (shared object) contains the object of class X (i.e libVWX.so contains X.o).

d. Executable a.exe contains X.cpp as part of translation units and finally is linked to libXYZ.so, libVWX.so

PS:
1. There are no user namespaces involved in any of the classes.
2. The libraries and executable contain many other classes also.
3. no dlopen() has been done. All libraries are linked during compile time using -L and -l flags.

Problem Statement:

  1. When compiling and linking a.exe with other libraries (i.e libXYZ.so and libVWX.so), I expected a linker error (conflict/occurance of same symbol multiple times) but did not get one.

  2. When the program was executed - the behavior was strange in SUSE 10 Linux and HP-UX 11 IA64.
    In Linux, when execution flow was pushed across all the objects in different libraries, the effect was registered in only one copy of X.
    In HPUX, when execution flow was pushed across all the objects in different libraries, the effect was registered in 3 differnt copies of X (2 belonging to each libraries and 1 for executable)

PS : I mean during running the program, the flow did passed thourgh multiple objects belonging to a.exe, libXYZ.so and libVWX.so) which interacted with static pointer belonging to X.

Question:

  • Is Expecting linker error not correct? Since two compilers passed through compilation silently, May be there is a standard rule in case of this type of scenario which I am missing. If so, Please let me know the same.
  • How does the compiler (gcc in Linux and aCC in HPUX) decide how many copies of X to keep in the final executable and refer them in such scenarios.
  • Is there any flag supported by gcc and aCC which will warn/stop compilation to the users in these kind of scenarios?

Thanks for your help in advance.

Improve this question
0

3 Answers 3

Reset to default
1

I'm not too sure that I've completely understood the scenario. However, the default behavior on loading dynamic objects under Linux (and other Unices) is to make all symbols in the library available, and to only use the first encountered. Thus, if you both libXYZ.so and libVWX.so contain a symbol X::ourData, it is not an error; if you load them in that order, libVWX.so will use the X::ourData from libXYZ.so, instead of its own. Logically, this is a lot like a template definition in a header: the compiler chooses one, more or less by chance, and if any of the definitions is not the same as all of the others, it's undefined behavior. This behavior can be overridden by passing the flag RTLD_LOCAL to dlopen.

With regards to your questions:

  • The linker is simply implementing the default behavior of dlopen (that which you get when the system loads the library implicitely). Thus, no error (but the logical equivalent of undefined behavior if any of the definitions isn't the same).

  • The compiler doesn't decide. The decision is made when the .so is loaded, depending on whether you specify RTLD_GLOBAL or RTLD_LOCAL when calling dlopen. When the runtime calls dlopen implicitly, to resolve a dependency, it will use RTLD_GLOBAL if this occurs when loading the main executable, and what ever was used to load the library when the dependency comes from a library. (This means, of course, that RTLD_GLOBAL will propagate until you invoke dlopen explicitly.)

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

2 Comments

Thanks for initial response, however, "Thus, if you both libXYZ.so and libVWX.so....." does not explain why the behavior is different in Linux and HPUX. In Linux, it goes in line with your explanation. But in HP, looks like the mySO::X::ourData is used to set the value of X.
@kumar_m_kiran I'm not familiar with HP-UX, so I can't say. Posix does say that if neither RTLD_GLOBAL nor RTLD_LOCAL are given, the default is implementation defined. The behavior I describe corresponds to that of the two platforms I know: Linux and Solaris.
0

The function is "public static", so I assume it's OOP-meaning of "static" (does not need instance), not C meaning of static (file-static; local to compilation unit). Therefore the functions are extern.

Now in Linux you have explicit right to override library symbols, both using another library or in the executable. All extern symbols in libraries are resolved using the global offset table, even the one the library actually defines itself. And while functions defined in the executable are normally not resolved like this, but the linker notices the symbols will get to the symbol table from the libraries and puts the reference to the executable-defined one there. So the libraries will see the symbol defined in the executable, if you generated it.

This is explicit feature, designed so you can do things like replace memory allocation functions or wrap filesystem operations. HP-UX probably does not have the feature, so each library ends up calling it's own implementation, while any other object that would have the symbol undefined will see one of them.

Improve this answer

2 Comments

Your answer looks to be the most logical. So have awarded you the points. Only open question still at large is - is there a way to find out these kinds of issue during linking time - where the linker will throw an error? If you are aware, Please let me know.
@kumar_m_kiran: Unfortunately it's system specific. ELF linker will declare conflict between symbols in two .o files unless those symbols are weak (in C++ inline methods and template instances are weak or you can use attribute) and will not declare conflict with symbols in libraries (by design). Windows on the other hand will declare conflict with any symbol, that is fatal unless overriden with option and even than shared libraries will still call their own definition.
0

There is a difference beetween "extern" symbols (which is the default in c++) and "shared libary extern". By default symbols are only "extern" which means the scope of one "link unit" e.g. an executable or a library. So the expected behaviour would be: no compiler error and every module works with its own copy. That leads to problems of course in case of inline compiling etc...etc... To declare a symbol "shared library extern" you have to use a ".def" file or an compiler declaration. e.g. in visual c++ that would be "_declspec(dllexport)" and "_declspec(dllimport)". I do not know the declarations for gcc at the moment but I am sure someone does :-)

Improve this answer

1 Comment

In Windows it's like that (except for the compiler error part; it is a linker error unless you override with /force). But Linux (ELF) behaves differently. It exports symbols by default (can explicitly hide them if you want) and always imports all symbols that it exports too (well, can be explicitly overridden too), so if multiple objects define the same symbol, they always all end up using the same definition.

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.