hello people.
i have a problem with my .so .
i am dynamically loading and unloading my libtemp.so using the dlopen and dlclose functions.
my .so contains many global instances of many classes.
i can see that all my global constructors are called on load and all my destructors are called on unload.
everything seems fine.
but when my program ends, i get a segmentation fault error.
here is my main.cpp:

int main( int argc, char * argv[] )
{
if( argc != 2 ){
printf("usage [so name] \n");
return 0;
}
printf("Before Load\r\n");
void* pHandle = dlopen(argv[1]);
if( pHandle == NULL ){
printf("%s\r\n", dlerror());
}else{
printf("Load: Went fine\r\n");
if( dlclose(pHandle) ){
printf("UnLoad Went Ok\r\n");
}else{
printf("UnLoad Failed\r\n");
}
}
return 0;
}

the output will be:
Before Load
Load: Went fine
UnLoad Went Ok
Segmentation fault

when debugging, i can see that my main reached it's ending, but still i get the segmentation fault error.
what might caused the problem ?
is it some memory leak ?
one of my globals problems ?
i will appreciate any help, cause i am kind of lost here.
thanks

I would expect the traceback and/or registers and/or stack contents at the point of the segmentation fault would give you a good hint about which cleanup code is failing.

If the crash is low enough in memory deallocation, then something overwrote memory that didn't belong to it, and you should be able to identify the clobbered address and rerun trapping all writes to that address.

If the crash is a call to a destructor that was located in the .so, that should be pretty obvious. I've hit many situations in Windows where an object is owned by some class static in the .exe but needs a destructor in the .dll, so the only way to avoid the crash at the end is never unload the .dll. I don't think I've seen that in Linux. I think the templated library I/O code that tends to cause such issues was coded more carefully to avoid questionable class statics in Linux than in Windows.

But anyway, once you find a call to unloaded code, it should be pretty easy to backtrack to the cause.