You might get lucky, but it would be better if the first one expressed an
explicit dependency on the second one.

That's a C++ mangled symbol name.

You didn't say what operating system you're on, but from the message above
I gather it's Solaris, so:

     -    You should construct your shared objects with explicit references
    to their dependencies, so that e.g. "ldd -r libMAP_Util.so"
    succeeds (i.e. doesn't complain about any unresolved references)
    without resorting to nonsense like LD_LIBRARY_PATH or ld.config.

    This will probably involve using -l, -L and -R when you build the
    shared objects.  

    If you are using sufficiently recent versions of Solaris (Solaris
    8 and above, I think, but you would need to check), then $ORIGIN
    with -R should be very helpful.

    One way to keep yourself honest is to add "-z defs" to the linker
    flags in your Makefile for the shared objects.

     -    Incidentally, do NOT call 'ld' directly to build the shared objects;
    always use your compiler frontend ('cc', 'CC', 'gcc', whatever) to
    invoke the linker for you.

    This may mean that you have to use funny syntax (such as "-Wl,") to
    tell the compiler frontend to pass a linker option (e.g. "-z defs")
    through to the linker for you.

     -    C++ makes all this a bit more complicated.  If it were me I would
    try to avoid C++ and just use C for everything in the shared objects,
    but...

     -    If you do have to use C++, be aware that (unless things have changed
    while I wasn't paying attention) gcc's C++ uses different calling
    conventions, libraries etc than Sun's C++ compiler.  Personally I
    wouldn't want to try mixing the two of them in one address space,
    and I believe that parts of the JVM already use Sun's C++ compiler,
    so that means if I had to use C++ for a shared object that's loaded
    into the JVM I would want to use Sun's C++ compiler (preferably the
    same version that was used to build the JVM), not gcc, in the
    interests of a quiet life.  But that's just me.

     -    Also, regardless of whether your code is C or C++, make sure that
    all your code is MT-safe, because (unless you carefully skirt this
    in your Java code) your JNI code may be invoked concurrently from
    multiple threads.  (Of course this isn't peculiar to Solaris, it's
    true for JNI code on any platform.  It used to be worse on Solaris
    because of ye olde Green Threads in the JVM, but thankfully these
    days the JVM on Solaris uses native threads).

Thomas Maslen
maslen@wedgetail.com