Bug 23252

Comment 1 Maxim Sobolev 2000-12-05 17:38:50 UTC

Responsible Changed
From-To: gnats-admin->obrien

Over to c++ maintainer.

I've analyzed this PR and am the opinion that it is not a threads library
bug.  It seems to have something to do with either the compiler (libgcc2)
or the implementation of string in libstdc++.  In the sample program included
with the original PR submittal, there are the following functions:

void
SS::run()
{
    string s;   // !!!
    string s1;  // !!!
    sleep(1);
}

static void sp_call(SS *ss)
{
    string s;   // !!!
    ss->spawn();
}

SS::run() is called from a thread that is created by the "ss->spawn()" call in
sp_call().  sp_call initializes/allocates the local string s, then creates a
thread that calls SS::run().  SS::run() is called which also initializes/allocates
2 strings (s and s1).  The thread then sleeps and a thread switch back to the
main thread occurs.  ss->spawn returns and the local string in sp_call() is
then finalized.  When the spawned thread returns from the sleep it also tries
to finalize the two strings (s and s1).  But it seems that the finalization
of the string in sp_call() has corrupted one of the strings in SS::run().

enclosed is another test program for this problem. execute it a bunch of 
times.  you'll see three or four different things depending on what causes 
death first:

these two mean an exception warped from one thread to another:

$ ./testex
B catches Z
Abort trap (core dumped)
or:
$ ./testex
A catches Y
Abort trap (core dumped)

this means that unexpected() was called by the runtime:

$ ./testex
unexpected exception thrown
Abort trap (core dumped)

and this means that the bit of unwinding code blew it:

$ ./testex
Segmentation fault (core dumped)

it dies in:

        leal 4(%edi),%edx
        movl (%edx),%eax
        addl $4,%eax
        movl (%eax),%edx
        movl (%edx),%ecx
        movl %ecx,(%eax)

because edx is zero.

/*
* testex.cpp
*
* this dumb program spins off a few threads that just throw and catch some
* exceptions.  it's supposed to run silently forever.  it'll print some 
stuff
* and exit if one of two things happens:
*
* 1) "unexpected()" is invoked by the runtime
* 2) the wrong exception is caught in a thread
*/

#include <stdio.h> // 11 15 37
#include <stdlib.h>
#include <pthread.h>
#include <new>
#include <exception>


// this is the exception thrown by instances of threadA
class exZ : public std::exception {

public:

    inline exZ(void) : std::exception() { }
    virtual ~exZ(void);

}; // class exZ

exZ::~exZ(
    void
    )
{
}


// this is the exception thrown by instances of threadB
class exY : public std::exception {

public:

    inline exY(void) : std::exception() { }
    virtual ~exY(void);

}; // class exY

exY::~exY(
    void
    )
{
}


// this is a synchronization device that mixes up the scheduling of threadA
// instances
class Flipper {

public:
    Flipper(void);
    ~Flipper(void);
    void Acquire(void);
    void Release(void);

private:
    pthread_t			 _owner;
    pthread_mutex_t		 _m;
    pthread_t			 _wanter;
    pthread_cond_t		*_wc;

}; // class Flipper


Flipper::Flipper(
    void
    ) : _owner(static_cast<pthread_t>(0)), 
_wanter(static_cast<pthread_t>(0)),
	_wc(NULL)
{
    pthread_mutex_init(&_m, NULL);
}


Flipper::~Flipper(
    void
    )
{
    pthread_mutex_destroy(&_m);
}


void Flipper::Acquire(
    void
    )
{
    pthread_t			 me = pthread_self();

    if (_owner == me)
	abort();

    pthread_mutex_lock(&_m);

    if (_owner == 0) {

	_owner = me;

    } else {

	pthread_cond_t		 myc;

	pthread_cond_init(&myc, NULL);

	_wanter = me;
	_wc = &myc;

	while (_owner != me)
	    pthread_cond_wait(&myc, &_m);

	pthread_cond_destroy(&myc);

    }

    pthread_mutex_unlock(&_m);
}


void Flipper::Release(
    void
    )
{
    pthread_mutex_lock(&_m);

    if (_wanter == 0) {

	_owner = static_cast<pthread_t>(0);

    } else {

	pthread_cond_t		*c = _wc;

	_owner = _wanter;
	_wanter = 0;
	_wc = NULL;

	pthread_cond_signal(c);

    }

    pthread_mutex_unlock(&_m);
}


// a stack object to automate flippage
class AutoFlip {

public:
    inline AutoFlip(Flipper *flip) : _flip(flip) {
	_flip->Acquire();
    }

    inline ~AutoFlip(void) {
	_flip->Release();
    }

private:
    Flipper			*_flip;

}; // class AutoFlip



// threadA's main processing loop.  pretty dumb.  it just trades off with
// another instance of threadA.
static void *threadAMain(
    void			*arg
    ) throw()
{
    Flipper			*flip = reinterpret_cast<Flipper *>(arg);

    do {

	try {
	    AutoFlip		 f(flip);

	    //printf("A throws Z\n");
	    throw exZ();

	} catch (const exZ &z) {
	    //printf("A catches Z\n");
	} catch (const exY &y) {
	    printf("A catches Y\n");
	    abort();
	}

    } while(true);

    return NULL;
}



// threadB's main processing loop.  even dumber.  it just throws exceptions
// at itself.
static void *threadBMain(
    void			*arg
    ) throw()
{
    do {

	try {
	    //printf("B throws Y\n");
	    throw exY();
	} catch (const exY &y) {
	    //printf("B catches Y\n");
	} catch (const exZ &z) {
	    printf("B catches Z\n");
	    abort();
	}

    } while(true);

    return NULL;
}


// handle unexpected exceptions (there shouldn't be any)
static void unexpectedHandler(
    void
    )
{
    printf("unexpected exception thrown\n");
    terminate();
}


// program entry point.  the join() will never complete, so there's no point
// in cleaning up the flipper.
int main(
    int				 argc,
    char			*argv[]
    ) throw()
{
    Flipper			*f;
    pthread_t			 thread;

    set_unexpected(unexpectedHandler);

    f = new Flipper();
    pthread_create(&thread, NULL, threadAMain, f);
    pthread_create(&thread, NULL, threadAMain, f);
    pthread_create(&thread, NULL, threadBMain, NULL);

    pthread_join(thread, NULL);

    return 0;
}
_________________________________________________________________
Get your FREE download of MSN Explorer at http://explorer.msn.com

The following hack stops test case from coredumping.

a) cd /usr/src/gnu/lib/libgcc_r
b) change CFLAGS+=-D_PTHREADS ÎÁ CFLAGS+=-D_PTHREADS -DGTHREAD_USE_WEAK=1
c) make all install
d) cp /usr/lib/libgcc/libgcc_r_pic.a /usr/lib/libgcc/libgcc_pic.a
e) cd /usr/src/gnu/lib/libstdc++; make clean all install

David, why can't we build libgcc_pic.a with -D_PTHREADS -DGTHREAD_USE_WEAK=1
always and get rid of libgcc_r_pic.a altogether? I just finished buildworld
after doing just that and everything seems to work so far. I will continue my
testing and will let you know if something breaks.

Comment 5 David E. O'Brien 2000-12-21 23:05:32 UTC

On Thu, Dec 21, 2000 at 05:50:34PM -0500, Alexander N. Kabaev wrote:
> David, why can't we build libgcc_pic.a with -D_PTHREADS -DGTHREAD_USE_WEAK=1
> always and get rid of libgcc_r_pic.a altogether? I just finished buildworld

I am working on something simular.

Comment 6 David E. O'Brien 2001-01-06 07:35:36 UTC

State Changed
From-To: open->closed

fix committed to -current and will be MFC'ed on the fast track