dynamic_cast incorrectly returns 0 in programs that load 
dynamic shared objects (DSOs) via dlopen(). 

Header file <typeinfo> assumes that typeinfo names are merged
across all DSOs in a program if weak symbols are supported.
At least on Linux, this assumption is wrong for DSOs loaded
via dlopen().

Note: This is more or less the same bug report as #4292; a workaround 
was suggested for #4292, and the case was closed.  The workaround -- 
using dlopen(..., RTLD_NOW | RTLD_GLOBAL) -- does not work, so I am 
resubmitting the bug with an updated example.

Release:
unknown

Environment:
gcc 3.0.1 / 3.0.2 on RedHat Linux 7.1 / Pentium

                 % g++ -v
                 Reading specs from /usr/local/lib/gcc-lib/i686-pc-linux-gnu/3.0.1/specs
                 Configured with: ../gcc-3.0.1/configure --enable-threads --prefix=/usr/local
                 --enable-languages=c,c++
                 Thread model: posix
                 gcc version 3.0.1

How-To-Repeat:
Reproducing the bug requires multiple source files:

                 a.C a.h main.C Makefile

                 The files are listed below.

                 The example program should print:

                 castInMain()
                 1
                 castInDso()
                 1
                 castInMain()
                 1
                 castInDso()
                 1

                 The program prints this instead:

                 castInMain()
                 1
                 castInDso()
                 0
                 castInMain()
                 0
                 castInDso()
                 1

                 The source files:

                 ::::::::::::::
                 a.C
                 ::::::::::::::
                 #include <a.h>
                 #include <iostream>

                 extern "C"
                 {
                 D *
                 DInDso ()
                 {
                 static D d;
                 return &d;
                 }

                 bool
                 castInDso (B *b)
                 {
                 std::cout << "castInDso()\n";
                 return 0 != dynamic_cast <D *> (b);
                 }
                 }

                 ::::::::::::::
                 a.h
                 ::::::::::::::
                 struct B
                 {
                 virtual ~B() {}
                 };

                 struct D: public B
                 {
                 virtual ~D() {}
                 };

                 ::::::::::::::
                 main.C
                 ::::::::::::::
                 #include <a.h>
                 #include <dlfcn.h>
                 #include <iostream>

                 using std::cout;
                 using std::endl;

                 extern "C"
                 {
                 typedef bool func1 (B *);
                 typedef D * func2 ();
                 }

                 bool
                 castInMain (B *b)
                 {
                 std::cout << "castInMain()\n";
                 return 0 != dynamic_cast <D *> (b);
                 }

                 int
                 main ()
                 {
                 void *liba = dlopen ("./liba.so", RTLD_NOW | RTLD_GLOBAL);

                 if (!liba)
                 {
                 cout << dlerror () << endl;
                 return 1;
                 }

                 func1 *castInDso = (func1 *) dlsym (liba, "castInDso");

                 if (!castInDso)
                 {
                 cout << dlerror () << endl;
                 return 1;
                 }

                 func2 *DInDso = (func2 *) dlsym (liba, "DInDso");

                 if (!DInDso)
                 {
                 cout << dlerror () << endl;
                 return 1;
                 }

                 {
                 D d;
                 cout << castInMain (&d) << endl;
                 cout << castInDso (&d) << endl;
                 }

                 {
                 D *d = DInDso();
                 cout << castInMain (d) << endl;
                 cout << castInDso (d) << endl;
                 }
                 }

                 ::::::::::::::
                 Makefile
                 ::::::::::::::
                 t = liba.so test 

                 all: $t

                 clean:
                 rm -f $t core

                 liba.so: a.C a.h
                 g++ -I. -shared -o $@ a.C

                 test: main.C a.h
                 g++ -I. -L. main.C -o $@ -ldl