Re: Shared Library Exceptions & Vague Linkage

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