Shared Library Exceptions & Vague Linkage

A

akennis

First of all, sorry for duplicating this post. I put it up in the
alt.comp.lang.learn.c-c++ mistakenly.

I'm investigating a problem whereby exceptions thrown from functions in
a Shared Library which was dynamically loaded (dlopen) are not properly
caught by the caller. Specifically, when compiling with G++ version
4.0, the RTTI data associated with the exception types is not being
properly aligned between the Shared Library and its caller.

The online manual for GCC describes this as a problem due to its
implementation of Vague Linkage, but does not fully explain how the
problem can be resolved.

I've been able to resolve the problem by taking the typeid of the
exception type before entering the try/catch block in the driver. This
is illustrated in the following code:

// DynamicLink.h
// **************

#ifndef dynamiclink_h
#define dynamiclink_h

#include <typeinfo>

namespace DynamicLink
{
I'm investigating a problem whereby exceptions thrown from functions in
a Shared Library which was dynamically loaded (dlopen) are not properly
caught by the caller. Specifically, when compiling with G++ version
4.0, the RTTI data associated with the exception types is not being
properly aligned between the Shared Library and its caller.

The online manual for GCC describes this as a problem due to its
implementation of Vague Linkage, but does not fully explain how the
problem can be resolved.

I've been able to resolve the problem by taking the typeid of the
exception type before entering the try/catch block in the driver. This
is illustrated in the following code:

// DynamicLink.h
// **************

#ifndef dynamiclink_h
#define dynamiclink_h

#include <typeinfo>

namespace DynamicLink
{

enum ExceptionType1
{
a = 0,
b = 1

};

extern "C" void throwExceptionType1();
typedef void (* throwExceptionType1_Fn)();

#ifdef FIX_VAGUE_LINKAGE

extern "C" void dumpRTTI();
typedef void (* dumpRTTI_Fn)();

char const * ExceptionType1__TypeId =
typeid(DynamicLink::ExceptionType1).name();

#endif

}

#endif

// DynamicLink.cpp
// ***************

// build: g++ -DFIX_VAGUE_LINKAGE -g -shared -o libDynamicLink.so
DynamicLink.cpp

#include "DynamicLink.h"

#include <stdio.h>

namespace DynamicLink
{

extern "C" void throwExceptionType1()
{
throw a;

}

#ifdef FIX_VAGUE_LINKAGE

extern "C" void dumpRTTI()
{
printf("Shared Library side RTTI:\n");
printf("typeid(ExceptionType1): %s %p\n", ExceptionType1__TypeId,
ExceptionType1__TypeId);

}

#endif

}

// Driver.cpp
// *********

// build: g++ -DFIX_VAGUE_LINKAGE -g -fpic -o DynamicLinkDriver -ldl
Driver.cpp

#include "DynamicLink.h"
using namespace DynamicLink;

#include <stdio.h>
#include <dlfcn.h>

int main(int argv, char const * * arc)
{
void * lib = dlopen("./libDynamicLink.so", RTLD_NOW | RTLD_GLOBAL);

#ifdef FIX_VAGUE_LINKAGE

dumpRTTI_Fn dumpRTTI_fn = (dumpRTTI_Fn) dlsym(lib, "dumpRTTI");
dumpRTTI_fn();
printf("Driver side RTTI:\n");
printf("typeid(ExceptionType1): %s %p\n", ExceptionType1__TypeId,
ExceptionType1__TypeId);

#endif

try
{
throwExceptionType1_Fn throwExceptionType1_fn =
(throwExceptionType1_Fn) dlsym(lib, "throwExceptionType1");
throwExceptionType1_fn();
}
catch (ExceptionType1 & e)
{
printf("caught ExceptionType1: %s %u - %u\n", __FILE__, __LINE__,
(int) e);
}
catch (...)
{
printf("caught unknown exception: %s %u\n", __FILE__, __LINE__);
}

dlclose(lib);

return 0;

}

// END CODE

If you compile the Shared Library and its associated executable driver
using the g++ commands given, then the proper exception handlers will
be executed. If you remove the -DFIX_VAGUE_LINKAGE directive from the
compile commands, then the catch (...) handler is erroniously executed.

The trick is putting the typeid(...) calls in the common header file.
Somehow this seems to resolve the typeid misalignment.

I would like to understand why this method is solving the problem, and
also if there is a better way to go about doing this. I suspect that
there is some combination of compiler / linker commands which can be
used, but I've yet to figure out which ones.

Thank you,

Albert Kennis
enum ExceptionType1
{
a = 0,
b = 1

};

extern "C" void throwExceptionType1();
typedef void (* throwExceptionType1_Fn)();

#ifdef FIX_VAGUE_LINKAGE

extern "C" void dumpRTTI();
typedef void (* dumpRTTI_Fn)();

char const * ExceptionType1__TypeId =
typeid(DynamicLink::ExceptionType1).name();

#endif

}

#endif

// DynamicLink.cpp
// ***************

// build: g++ -DFIX_VAGUE_LINKAGE -g -shared -o libDynamicLink.so
DynamicLink.cpp

#include "DynamicLink.h"

#include <stdio.h>

namespace DynamicLink
{

extern "C" void throwExceptionType1()
{
throw a;

}

#ifdef FIX_VAGUE_LINKAGE

extern "C" void dumpRTTI()
{
printf("Shared Library side RTTI:\n");
printf("typeid(ExceptionType1): %s %p\n", ExceptionType1__TypeId,
ExceptionType1__TypeId);

}

#endif

}

// Driver.cpp
// *********

// build: g++ -DFIX_VAGUE_LINKAGE -g -fpic -o DynamicLinkDriver -ldl
Driver.cpp

#include "DynamicLink.h"
using namespace DynamicLink;

#include <stdio.h>
#include <dlfcn.h>

int main(int argv, char const * * arc)
{
void * lib = dlopen("./libDynamicLink.so", RTLD_NOW | RTLD_GLOBAL);

#ifdef FIX_VAGUE_LINKAGE

dumpRTTI_Fn dumpRTTI_fn = (dumpRTTI_Fn) dlsym(lib, "dumpRTTI");
dumpRTTI_fn();
printf("Driver side RTTI:\n");
printf("typeid(ExceptionType1): %s %p\n", ExceptionType1__TypeId,
ExceptionType1__TypeId);

#endif

try
{
throwExceptionType1_Fn throwExceptionType1_fn =
(throwExceptionType1_Fn) dlsym(lib, "throwExceptionType1");
throwExceptionType1_fn();
}
catch (ExceptionType1 & e)
{
printf("caught ExceptionType1: %s %u - %u\n", __FILE__, __LINE__,
(int) e);
}
catch (...)
{
printf("caught unknown exception: %s %u\n", __FILE__, __LINE__);
}

dlclose(lib);

return 0;

}

// END CODE

If you compile the Shared Library and its associated executable driver
using the g++ commands given, then the proper exception handlers will
be executed. If you remove the -DFIX_VAGUE_LINKAGE directive from the
compile commands, then the catch (...) handler is erroniously executed.

The trick is putting the typeid(...) calls in the common header file.
Somehow this seems to resolve the typeid misalignment.

I would like to understand why this method is solving the problem, and
also if there is a better way to go about doing this. I suspect that
there is some combination of compiler / linker commands which can be
used, but I've yet to figure out which ones.

Thank you,

Albert Kennis
 
A

akennis

I mixed up the message text - sorry again:

I'm investigating a problem whereby exceptions thrown from functions in
a Shared Library which was dynamically loaded (dlopen) are not properly
caught by the caller. Specifically, when compiling with G++ version
4.0, the RTTI data associated with the exception types is not being
properly aligned between the Shared Library and its caller.

The online manual for GCC describes this as a problem due to its
implementation of Vague Linkage, but does not fully explain how the
problem can be resolved.

I've been able to resolve the problem by taking the typeid of the
exception type before entering the try/catch block in the driver. This
is illustrated in the following code:

// DynamicLink.h
// **************

#ifndef dynamiclink_h
#define dynamiclink_h

#include <typeinfo>

namespace DynamicLink
{

enum ExceptionType1
{
a = 0,
b = 1

};

extern "C" void throwExceptionType1();
typedef void (* throwExceptionType1_Fn)();

#ifdef FIX_VAGUE_LINKAGE

extern "C" void dumpRTTI();
typedef void (* dumpRTTI_Fn)();

char const * ExceptionType1__TypeId =
typeid(DynamicLink::ExceptionType1).name();

#endif

}

#endif

// DynamicLink.cpp
// ***************

// build: g++ -DFIX_VAGUE_LINKAGE -g -shared -o libDynamicLink.so
DynamicLink.cpp

#include "DynamicLink.h"

#include <stdio.h>

namespace DynamicLink
{

extern "C" void throwExceptionType1()
{
throw a;

}

#ifdef FIX_VAGUE_LINKAGE

extern "C" void dumpRTTI()
{
printf("Shared Library side RTTI:\n");
printf("typeid(ExceptionType1): %s %p\n", ExceptionType1__TypeId,
ExceptionType1__TypeId);

}

#endif

}

// Driver.cpp
// *********

// build: g++ -DFIX_VAGUE_LINKAGE -g -fpic -o DynamicLinkDriver -ldl
Driver.cpp

#include "DynamicLink.h"
using namespace DynamicLink;

#include <stdio.h>
#include <dlfcn.h>

int main(int argv, char const * * arc)
{
void * lib = dlopen("./libDynamicLink.so", RTLD_NOW | RTLD_GLOBAL);

#ifdef FIX_VAGUE_LINKAGE

dumpRTTI_Fn dumpRTTI_fn = (dumpRTTI_Fn) dlsym(lib, "dumpRTTI");
dumpRTTI_fn();
printf("Driver side RTTI:\n");
printf("typeid(ExceptionType1): %s %p\n", ExceptionType1__TypeId,
ExceptionType1__TypeId);

#endif

try
{
throwExceptionType1_Fn throwExceptionType1_fn =
(throwExceptionType1_Fn) dlsym(lib, "throwExceptionType1");
throwExceptionType1_fn();
}
catch (ExceptionType1 & e)
{
printf("caught ExceptionType1: %s %u - %u\n", __FILE__, __LINE__,
(int) e);
}
catch (...)
{
printf("caught unknown exception: %s %u\n", __FILE__, __LINE__);
}

dlclose(lib);

return 0;

}

// END CODE

If you compile the Shared Library and its associated executable driver
using the g++ commands given, then the proper exception handlers will
be executed. If you remove the -DFIX_VAGUE_LINKAGE directive from the
compile commands, then the catch (...) handler is erroniously executed.

The trick is putting the typeid(...) calls in the common header file.
Somehow this seems to resolve the typeid misalignment.

I would like to understand why this method is solving the problem, and
also if there is a better way to go about doing this. I suspect that
there is some combination of compiler / linker commands which can be
used, but I've yet to figure out which ones.

Thank you,

Albert Kennis
 
J

Jack Klein

First of all, sorry for duplicating this post. I put it up in the
alt.comp.lang.learn.c-c++ mistakenly.

I'm investigating a problem whereby exceptions thrown from functions in
a Shared Library which was dynamically loaded (dlopen) are not properly
caught by the caller. Specifically, when compiling with G++ version
4.0, the RTTI data associated with the exception types is not being
properly aligned between the Shared Library and its caller.
Click to expand...

[snip]

You're still in the wrong place. C++ does not have or define shared
libraries, dynamic loading, or dlopen().
 
P

Peter

akennis said:
First of all, sorry for duplicating this post. I put it up in the
alt.comp.lang.learn.c-c++ mistakenly.

I'm investigating a problem whereby exceptions thrown from functions in
a Shared Library which was dynamically loaded (dlopen) are not properly
caught by the caller. Specifically, when compiling with G++ version
4.0, the RTTI data associated with the exception types is not being
properly aligned between the Shared Library and its caller.
Click to expand...


make certain that you have only one definition of the matching symbols
in all of your exceutable and shared libraries.
I guess this is being caused by having multiple copies of the matching
code inside the excecutable and again inside the shared library
 
A

akennis

Peter said:
make certain that you have only one definition of the matching symbols
in all of your exceutable and shared libraries.
I guess this is being caused by having multiple copies of the matching
code inside the excecutable and again inside the shared library
Click to expand...

If the -DFIX_VAGUE_LINKAGE command is removed, then the only code
common between the shared library and the executable are the type &
function declarations in the header file. These are required inorder
to establish the shared library API.

I think that the type_info objects are being compiled into the binaries
automatically, and so these ARE present in both. How can I prevent the
type_info stuff from being compiled into the executable?

Thanks.
 
P

Peter

akennis said:
void * lib = dlopen("./libDynamicLink.so", RTLD_NOW | RTLD_GLOBAL);
....
dlclose(lib);
Click to expand...


dlopen belongs into a constructor and dlclose into the matching
destructor.
If dlopen fails throw an exception containing the error information.
 
P

Peter

akennis said:
try
{
throwExceptionType1_Fn throwExceptionType1_fn =
(throwExceptionType1_Fn) dlsym(lib, "throwExceptionType1");
throwExceptionType1_fn();
}
catch (ExceptionType1 & e)
Click to expand...


it is unlikely that you want to modify the exception inside the catch
block.
Thus catch a const reference of this type.
 
P

Peter

akennis said:
I mixed up the message text - sorry again:
Click to expand...


I did not know that it is possible to get the typeid for an
enumeration.
Try again with a class which has at least one virtual function
-- e.g. derived from the standard exception class.

And also -- the call to dlsym() belongs into a C++ wrapper which checks
for success and throws an exception otherwise.
The assumption being that you write such a wrapper only once and reuse
it.
And another assumption being that at the place where you call dlopen()
you don't want to deal with the possibility that it may fail,
but you want to delegate this task to some piece of code up the stack.
 

Ask a Question

Want to reply to this thread or ask your own question?

You'll need to choose a username for the site, which only take a couple of moments. After that, you can post your question and our members will help you out.

Ask a Question

Similar Threads

default argument and shared library 9
extern "C" friend function without external linkage 2
Exceptions in class 7
templates + RTTI + shared library = impossible? 11
howto share a list between C++ library and appl 0
prevent linking of some functions in a shared library 1
Python/C API: using from a shared library 2
How to throw standard exceptions ? 1

Members online

Total: 36 (members: 1, guests: 35)
Robots: 463

Forum statistics

Threads
473,769
Messages
2,569,580
Members
45,054
Latest member
TrimKetoBoost

Latest Threads

Top