Happy chainsaw stories; The removal of the 5005 threads

Still imcomplete. Configure will follow

p4raw-id: //depot/perl@18030

2 files changed, 7 insertions, 823 deletions

diff --git a/ext/Thread/README.threads b/ext/Thread/README.threads
index 9cd0dbcb20..6e4d13344b 100644
--- a/ext/Thread/README.threads
+++ b/ext/Thread/README.threads
@@ -7,333 +7,7 @@ available only internally and to XS extension builders, and used
 by the Win32 port for emulating fork()). As of Perl 5.8.0, ithreads has
 become the standard threading model for Perl.
 
-If you really want the older support for threads described below,
-it is enabled with:
-
-    sh Configure -Dusethreads -Duse5005threads
-
-Be warned that the old 5.005 implementation of threads is known
-to be quite buggy, and unmaintained, which means that the bugs
-are there to stay.  (We are not mean by not fixing the bugs:
-the bugs are just really, really, really hard to fix.  Honest.)
-
-The rest of this document only applies to the use5005threads style of
-threads, and the comments on what works on which platform are highly
-obsolete and preserved here for archaeology buffs only.  The
-architecture specific hints files do all the necessary option
-tweaking automatically during Configure, both for the 5.005 threads
-and for the new interpreter threads.
-
----------------------------------------------------------------------------
-
-Support for threading is still in the highly experimental stages.  There
-are known race conditions that show up under high contention on SMP
-machines.  Internal implementation is still subject to changes.
-It is not recommended for production use at this time.
-
----------------------------------------------------------------------------
-
-Building
-
-If your system is in the following list you should be able to just:
-
-    ./Configure -Dusethreads -Duse5005threads -des
-    make
-
-and ignore the rest of this "Building" section.  If not, continue
-from the "Problems" section.
-
-	* Linux 2.* (with the LinuxThreads library installed:
-	  that's the linuxthreads and linuxthreads-devel RPMs
-	  for RedHat)
-
-	* Tru64 UNIX (formerly Digital UNIX formerly DEC OSF/1)
-	  (see additional note below)
-
-	* Solaris 2.* for recentish x (2.5 is OK)
-
-	* IRIX 6.2 or newer. 6.2 will require a few OS patches.
-	  IMPORTANT: Without patch 2401 (or its replacement),
-	  a kernel bug in IRIX 6.2 will cause your machine to
-	  panic and crash when running threaded perl.
-	  IRIX 6.3 and up should be OK. See lower down for patch details.
-
-	* AIX 4.1.5 or newer.
-
-	* FreeBSD 2.2.8 or newer.
-
-	* OpenBSD
-
-	* NeXTstep, OpenStep
-
-	* OS/2
-
-	* DOS DJGPP
-
-	* VM/ESA
-
----------------------------------------------------------------------------
-
-Problems
-
-If the simple way doesn't work or you are using another platform which
-you believe supports POSIX.1c threads then read on.  Additional
-information may be in a platform-specific "hints" file in the hints/
-subdirectory.
-
-On platforms that use Configure to build perl, omit the -d from your
-./Configure arguments. For example, use:
-
-    ./Configure -Dusethreads -Duse5005threads
-
-When Configure prompts you for ccflags, insert any other arguments in
-there that your compiler needs to use POSIX threads (-D_REENTRANT,
--pthreads, -threads, -pthread, -thread, are good guesses). When
-Configure prompts you for linking flags, include any flags required
-for threading (usually nothing special is required here).  Finally,
-when Configure prompts you for libraries, include any necessary
-libraries (e.g. -lpthread).  Pay attention to the order of libraries.
-It is probably necessary to specify your threading library *before*
-your standard C library, e.g.  it might be necessary to have -lpthread
--lc, instead of -lc -lpthread.  You may also need to use -lc_r instead
-of -lc.
-
-Once you have specified all your compiler flags, you can have Configure
-accept all the defaults for the remainder of the session by typing  &-d
-at any Configure prompt.
-
-Some additional notes (some of these may be obsolete now, other items
-may be handled automatically):
-
-For Digital Unix 4.x:
-    Add -pthread to ccflags
-    Add -pthread to ldflags
-    Add -lpthread -lc_r to lddlflags
-
-    For some reason, the extra includes for pthreads make Digital UNIX
-    complain fatally about the sbrk() declaration in perl's malloc.c
-    so use the native malloc, e.g.  sh Configure -Uusemymalloc, or
-    manually edit your config.sh as follows:
-	Change usemymalloc to n
-	Zap mallocobj and mallocsrc (foo='')
-	Change d_mymalloc to undef
-
-For Digital Unix 3.x (Formerly DEC OSF/1):
-    Add -DOLD_PTHREADS_API to ccflags
-    If compiling with the GNU cc compiler, remove -threads from ccflags
-
-    (The following should be done automatically if you call Configure
-      with the -Dusethreads option).
-    Add -lpthread -lmach -lc_r to libs (in the order specified).
-
-For IRIX:
-    (This should all be done automatically by the hint file).
-    Add -lpthread to libs
-    For IRIX 6.2, you have to have the following patches installed:
-	1404 Irix 6.2 Posix 1003.1b man pages
-	1645 IRIX 6.2 & 6.3 POSIX header file updates
-	2000 Irix 6.2 Posix 1003.1b support modules
-	2254 Pthread library fixes
-	2401 6.2 all platform kernel rollup
-    IMPORTANT: Without patch 2401, a kernel bug in IRIX 6.2 will
-    cause your machine to panic and crash when running threaded perl.
-    IRIX 6.3 and up should be OK.
-
-    For IRIX 6.3 and 6.4 the pthreads should work out of the box.
-    Thanks to Hannu Napari <Hannu.Napari@hut.fi> for the IRIX
-    pthreads patches information.
-
-For AIX:
-    (This should all be done automatically by the hint file).
-    Change cc to xlc_r or cc_r.
-    Add -DNEED_PTHREAD_INIT to ccflags and cppflags
-    Add -lc_r to libswanted
-    Change -lc in lddflags to be -lpthread -lc_r -lc
-
-For Win32:
-    See README.win32, and the notes at the beginning of win32/Makefile
-    or win32/makefile.mk.
-
-Now you can do a
-    make
-
-When you succeed in compiling and testing ("make test" after your
-build) a threaded Perl in a platform previously unknown to support
-threaded perl, please let perlbug@perl.com know about your victory.
-Explain what you did in painful detail.
-
----------------------------------------------------------------------------
-
-O/S specific bugs
-
-Irix 6.2:  See the Irix warning above.
-
-LinuxThreads 0.5 has a bug which can cause file descriptor 0 to be
-closed after a fork() leading to many strange symptoms. Version 0.6
-has this fixed but the following patch can be applied to 0.5 for now:
-
------------------------------ cut here -----------------------------
---- linuxthreads-0.5/pthread.c.ORI	Mon Oct  6 13:55:50 1997
-+++ linuxthreads-0.5/pthread.c	Mon Oct  6 13:57:24 1997
-@@ -312,8 +312,10 @@
-   free(pthread_manager_thread_bos);
-   pthread_manager_thread_bos = pthread_manager_thread_tos = NULL;
-   /* Close the two ends of the pipe */
--  close(pthread_manager_request);
--  close(pthread_manager_reader);
-+  if (pthread_manager_request >= 0) {
-+    close(pthread_manager_request);
-+    close(pthread_manager_reader);
-+  }
-   pthread_manager_request = pthread_manager_reader = -1;
-   /* Update the pid of the main thread */
-   self->p_pid = getpid();
------------------------------ cut here -----------------------------
-
-
-Building the Thread extension
-
-The Thread extension is now part of the main perl distribution tree.
-If you did Configure -Dusethreads -Duse5005threads then it will have been
-added to the list of extensions automatically.
-
-You can try some of the tests with
-    cd ext/Thread
-    perl create.t
-    perl join.t
-    perl lock.t
-    perl io.t
-etc.
-The io one leaves a thread reading from the keyboard on stdin so
-as the ping messages appear you can type lines and see them echoed.
-
-Try running the main perl test suite too. There are known
-failures for some of the DBM/DB extensions (if their underlying
-libraries were not compiled to be thread-aware).
-
----------------------------------------------------------------------------
-
-Bugs
-
-* FAKE_THREADS should produce a working perl but the Thread
-extension won't build with it yet.  (FAKE_THREADS has not been
-tested at all in recent times.)
-
-* There may still be races where bugs show up under contention.
-
----------------------------------------------------------------------------
-
-Debugging
-
-Use the -DS command-line option to turn on debugging of the
-multi-threading code. Under Linux, that also turns on a quick
-hack I did to grab a bit of extra information from segfaults.
-If you have a fancier gdb/threads setup than I do then you'll
-have to delete the lines in perl.c which say
-    #if defined(DEBUGGING) && defined(USE_5005THREADS) && defined(__linux__)
-        DEBUG_S(signal(SIGSEGV, (void(*)(int))catch_sigsegv););
-    #endif
-
----------------------------------------------------------------------------
-
-Background
-
-Some old globals (e.g. stack_sp, op) and some old per-interpreter
-variables (e.g. tmps_stack, cxstack) move into struct thread.
-All fields of struct thread which derived from original perl
-variables have names of the form Tfoo. For example, stack_sp becomes
-the field Tstack_sp of struct thread. For those fields which moved
-from original perl, thread.h does
-    #define foo (thr->Tfoo)
-This means that all functions in perl which need to use one of these
-fields need an (automatic) variable thr which points at the current
-thread's struct thread. For pp_foo functions, it is passed around as
-an argument, for other functions they do
-    dTHR;
-which declares and initialises thr from thread-specific data
-via pthread_getspecific. If a function fails to compile with an
-error about "no such variable thr", it probably just needs a dTHR
-at the top.
-
-
-Fake threads
-
-For FAKE_THREADS, thr is a global variable and perl schedules threads
-by altering thr in between appropriate ops. The next and prev fields
-of struct thread keep all fake threads on a doubly linked list and
-the next_run and prev_run fields keep all runnable threads on a
-doubly linked list. Mutexes are stubs for FAKE_THREADS. Condition
-variables are implemented as a list of waiting threads.
-
-
-Mutexes and condition variables
-
-The API is via macros MUTEX_{INIT,LOCK,UNLOCK,DESTROY} and
-COND_{INIT,WAIT,SIGNAL,BROADCAST,DESTROY}.
-
-A mutex is only required to be a simple, fast mutex (e.g. it does not
-have to be recursive). It is only ever held across very short pieces
-of code. Condition variables are only ever signalled/broadcast while
-their associated mutex is held. (This constraint simplifies the
-implementation of condition variables in certain porting situations.)
-For POSIX threads, perl mutexes and condition variables correspond to
-POSIX ones.  For FAKE_THREADS, mutexes are stubs and condition variables
-are implemented as lists of waiting threads. For FAKE_THREADS, a thread
-waits on a condition variable by removing itself from the runnable
-list, calling SCHEDULE to change thr to the next appropriate
-runnable thread and returning op (i.e. the new threads next op).
-This means that fake threads can only block while in PP code.
-A PP function which contains a COND_WAIT must be prepared to
-handle such restarts and can use the field "private" of struct
-thread to record its state. For fake threads, COND_SIGNAL and
-COND_BROADCAST work by putting back all the threads on the
-condition variables list into the run queue. Note that a mutex
-must *not* be held while returning from a PP function.
-
-Perl locks and condition variables are both implemented as a
-condpair_t structure, containing a mutex, an "owner" condition
-variable, an owner thread field and another condition variable).
-The structure is attached by 'm' magic to any SV. pp_lock locks
-such an object by waiting on the ownercond condition variable until
-the owner field is zero and then setting the owner field to its own
-thread pointer. The lock is semantically recursive so if the owner
-field already matches the current thread then pp_lock returns
-straight away. If the owner field has to be filled in then
-unlock_condpair is queued as an end-of-block destructor and
-that function zeroes out the owner field and signals the ownercond
-condition variable, thus waking up any other thread that wants to
-lock it. When used as a condition variable, the condpair is locked
-(involving the above wait-for-ownership and setting the owner field)
-and the spare condition variable field is used for waiting on.
-
-
-Thread states
-
-
-              $t->join
-R_JOINABLE ---------------------> R_JOINED >----\
-    |      \  pthread_join(t)         |  ^      |
-    |       \                         |  | join | pthread_join
-    |        \                        |  |      |
-    |         \                       |  \------/
-    |          \                      |
-    |           \                     |
-    |  $t->detach\ pthread_detach     |
-    |            _\|                  |
-ends|             R_DETACHED     ends | unlink
-    |                       \         |
-    |                   ends \ unlink |
-    |                         \       |
-    |                          \      |
-    |                           \     |
-    |                            \    |
-    |                             \   |
-    V    join          detach     _\| V
-ZOMBIE ----------------------------> DEAD
-       pthread_join   pthread_detach
-       and unlink     and unlink
-
-
+As of 5.9.0, the older threading model is not supported anymore.
 
 Malcolm Beattie
 mbeattie@sable.ox.ac.uk
@@ -347,3 +21,6 @@ Gurusamy Sarathy
 
 More platforms added 26 Jul 1999 by
 Jarkko Hietaniemi
+
+Removed 5005threads support 03 Oct 2002 by
+H.Merijn Brand
diff --git a/ext/Thread/Thread.xs b/ext/Thread/Thread.xs
index b76c0be18b..14740097f7 100644
--- a/ext/Thread/Thread.xs
+++ b/ext/Thread/Thread.xs
@@ -23,316 +23,25 @@ static int sig_pipe[2];
 static void
 remove_thread(pTHX_ Thread t)
 {
-#ifdef USE_5005THREADS
-    DEBUG_S(WITH_THR(PerlIO_printf(Perl_debug_log,
-				   "%p: remove_thread %p\n", thr, t)));
-    MUTEX_LOCK(&PL_threads_mutex);
-    MUTEX_DESTROY(&t->mutex);
-    PL_nthreads--;
-    t->prev->next = t->next;
-    t->next->prev = t->prev;
-    SvREFCNT_dec(t->oursv);
-    COND_BROADCAST(&PL_nthreads_cond);
-    MUTEX_UNLOCK(&PL_threads_mutex);
-#endif
 }
 
 static THREAD_RET_TYPE
 threadstart(void *arg)
 {
-#ifdef USE_5005THREADS
-#ifdef FAKE_THREADS
-    Thread savethread = thr;
-    LOGOP myop;
-    dSP;
-    I32 oldscope = PL_scopestack_ix;
-    I32 retval;
-    AV *av;
-    int i;
-
-    DEBUG_S(PerlIO_printf(Perl_debug_log, "new thread %p starting at %s\n",
-			  thr, SvPEEK(TOPs)));
-    thr = (Thread) arg;
-    savemark = TOPMARK;
-    thr->prev = thr->prev_run = savethread;
-    thr->next = savethread->next;
-    thr->next_run = savethread->next_run;
-    savethread->next = savethread->next_run = thr;
-    thr->wait_queue = 0;
-    thr->private = 0;
-
-    /* Now duplicate most of perl_call_sv but with a few twists */
-    PL_op = (OP*)&myop;
-    Zero(PL_op, 1, LOGOP);
-    myop.op_flags = OPf_STACKED;
-    myop.op_next = Nullop;
-    myop.op_flags |= OPf_KNOW;
-    myop.op_flags |= OPf_WANT_LIST;
-    PL_op = pp_entersub(ARGS);
-    DEBUG_S(if (!PL_op)
-	    PerlIO_printf(Perl_debug_log, "thread starts at Nullop\n"));
-    /*
-     * When this thread is next scheduled, we start in the right
-     * place. When the thread runs off the end of the sub, perl.c
-     * handles things, using savemark to figure out how much of the
-     * stack is the return value for any join.
-     */
-    thr = savethread;		/* back to the old thread */
-    return 0;
-#else
-    Thread thr = (Thread) arg;
-    dSP;
-    I32 oldmark = TOPMARK;
-    I32 retval;
-    SV *sv;
-    AV *av;
-    int i;
-
-#if defined(MULTIPLICITY)
-    PERL_SET_INTERP(thr->interp);
-#endif
-
-    DEBUG_S(PerlIO_printf(Perl_debug_log, "new thread %p waiting to start\n",
-			  thr));
-
-    /*
-     * Wait until our creator releases us. If we didn't do this, then
-     * it would be potentially possible for out thread to carry on and
-     * do stuff before our creator fills in our "self" field. For example,
-     * if we went and created another thread which tried to JOIN with us,
-     * then we'd be in a mess.
-     */
-    MUTEX_LOCK(&thr->mutex);
-    MUTEX_UNLOCK(&thr->mutex);
-
-    /*
-     * It's safe to wait until now to set the thread-specific pointer
-     * from our pthread_t structure to our struct perl_thread, since
-     * we're the only thread who can get at it anyway.
-     */
-    PERL_SET_THX(thr);
-
-    DEBUG_S(PerlIO_printf(Perl_debug_log, "new thread %p starting at %s\n",
-			  thr, SvPEEK(TOPs)));
-
-    av = newAV();
-    sv = POPs;
-    PUTBACK;
-    ENTER;
-    SAVETMPS;
-    perl_call_sv(sv, G_ARRAY|G_EVAL);
-    SPAGAIN;
-    retval = SP - (PL_stack_base + oldmark);
-    SP = PL_stack_base + oldmark + 1;
-    if (SvCUR(thr->errsv)) {
-	MUTEX_LOCK(&thr->mutex);
-	thr->flags |= THRf_DID_DIE;
-	MUTEX_UNLOCK(&thr->mutex);
-	av_store(av, 0, &PL_sv_no);
-	av_store(av, 1, newSVsv(thr->errsv));
-	DEBUG_S(PerlIO_printf(Perl_debug_log, "%p died: %s\n",
-			      thr, SvPV(thr->errsv, PL_na)));
-    }
-    else {
-	DEBUG_S(STMT_START {
-	    for (i = 1; i <= retval; i++) {
-		PerlIO_printf(Perl_debug_log, "%p return[%d] = %s\n",
-				thr, i, SvPEEK(SP[i - 1]));
-	    }
-	} STMT_END);
-	av_store(av, 0, &PL_sv_yes);
-	for (i = 1; i <= retval; i++, SP++)
-	    sv_setsv(*av_fetch(av, i, TRUE), SvREFCNT_inc(*SP));
-    }
-    FREETMPS;
-    LEAVE;
-
-#if 0    
-    /* removed for debug */
-    SvREFCNT_dec(PL_curstack);
-#endif
-    SvREFCNT_dec(thr->cvcache);
-    SvREFCNT_dec(thr->threadsv);
-    SvREFCNT_dec(thr->specific);
-    SvREFCNT_dec(thr->errsv);
-
-    /*Safefree(cxstack);*/
-    while (PL_curstackinfo->si_next)
-	PL_curstackinfo = PL_curstackinfo->si_next;
-    while (PL_curstackinfo) {
-	PERL_SI *p = PL_curstackinfo->si_prev;
-	SvREFCNT_dec(PL_curstackinfo->si_stack);
-	Safefree(PL_curstackinfo->si_cxstack);
-	Safefree(PL_curstackinfo);
-	PL_curstackinfo = p;
-    }    
-    Safefree(PL_markstack);
-    Safefree(PL_scopestack);
-    Safefree(PL_savestack);
-    Safefree(PL_retstack);
-    Safefree(PL_tmps_stack);
-    SvREFCNT_dec(PL_ofs_sv);
-
-    SvREFCNT_dec(PL_rs);
-    SvREFCNT_dec(PL_statname);
-    SvREFCNT_dec(PL_errors);
-    Safefree(PL_screamfirst);
-    Safefree(PL_screamnext);
-    Safefree(PL_reg_start_tmp);
-    SvREFCNT_dec(PL_lastscream);
-    SvREFCNT_dec(PL_defoutgv);
-    Safefree(PL_reg_poscache);
-
-    MUTEX_LOCK(&thr->mutex);
-    thr->thr_done = 1;
-    DEBUG_S(PerlIO_printf(Perl_debug_log,
-			  "%p: threadstart finishing: state is %u\n",
-			  thr, ThrSTATE(thr)));
-    switch (ThrSTATE(thr)) {
-    case THRf_R_JOINABLE:
-	ThrSETSTATE(thr, THRf_ZOMBIE);
-	MUTEX_UNLOCK(&thr->mutex);
-	DEBUG_S(PerlIO_printf(Perl_debug_log,
-			      "%p: R_JOINABLE thread finished\n", thr));
-	break;
-    case THRf_R_JOINED:
-	ThrSETSTATE(thr, THRf_DEAD);
-	MUTEX_UNLOCK(&thr->mutex);
-	remove_thread(aTHX_ thr);
-	DEBUG_S(PerlIO_printf(Perl_debug_log,
-			      "%p: R_JOINED thread finished\n", thr));
-	break;
-    case THRf_R_DETACHED:
-	ThrSETSTATE(thr, THRf_DEAD);
-	MUTEX_UNLOCK(&thr->mutex);
-	SvREFCNT_dec(av);
-	DEBUG_S(PerlIO_printf(Perl_debug_log,
-			      "%p: DETACHED thread finished\n", thr));
-	remove_thread(aTHX_ thr);	/* This might trigger main thread to finish */
-	break;
-    default:
-	MUTEX_UNLOCK(&thr->mutex);
-	croak("panic: illegal state %u at end of threadstart", ThrSTATE(thr));
-	/* NOTREACHED */
-    }
-    return THREAD_RET_CAST(av);	/* Available for anyone to join with */
-					/* us unless we're detached, in which */
-					/* case noone sees the value anyway. */
-#endif    
-#else
     return THREAD_RET_CAST(NULL);
-#endif
 }
 
 static SV *
 newthread (pTHX_ SV *startsv, AV *initargs, char *classname)
 {
-#ifdef USE_5005THREADS
-    dSP;
-    Thread savethread;
-    int i;
-    SV *sv;
-    int err;
-#ifndef THREAD_CREATE
-    static pthread_attr_t attr;
-    static int attr_inited = 0;
-    sigset_t fullmask, oldmask;
-    static int attr_joinable = PTHREAD_CREATE_JOINABLE;
-#endif
-
-    savethread = thr;
-    thr = new_struct_thread(thr);
-    /* temporarily pretend to be the child thread in case the
-     * XPUSHs() below want to grow the child's stack.  This is
-     * safe, since the other thread is not yet created, and we
-     * are the only ones who know about it */
-    PERL_SET_THX(thr);
-    SPAGAIN;
-    DEBUG_S(PerlIO_printf(Perl_debug_log,
-			  "%p: newthread (%p), tid is %u, preparing stack\n",
-			  savethread, thr, thr->tid));
-    /* The following pushes the arg list and startsv onto the *new* stack */
-    PUSHMARK(SP);
-    /* Could easily speed up the following greatly */
-    for (i = 0; i <= AvFILL(initargs); i++)
-	XPUSHs(SvREFCNT_inc(*av_fetch(initargs, i, FALSE)));
-    XPUSHs(SvREFCNT_inc(startsv));
-    PUTBACK;
-
-    /* On your marks... */
-    PERL_SET_THX(savethread);
-    MUTEX_LOCK(&thr->mutex);
-
-#ifdef THREAD_CREATE
-    err = THREAD_CREATE(thr, threadstart);
-#else    
-    /* Get set...  */
-    sigfillset(&fullmask);
-    if (sigprocmask(SIG_SETMASK, &fullmask, &oldmask) == -1)
-	croak("panic: sigprocmask");
-    err = 0;
-    if (!attr_inited) {
-	attr_inited = 1;
-	err = pthread_attr_init(&attr);
-#  ifdef THREAD_CREATE_NEEDS_STACK
-       if (err == 0)
-            err = pthread_attr_setstacksize(&attr, THREAD_CREATE_NEEDS_STACK);
-       if (err)
-           croak("panic: pthread_attr_setstacksize failed");
-#  endif
-#  ifdef PTHREAD_ATTR_SETDETACHSTATE
-	if (err == 0)
-	    err = PTHREAD_ATTR_SETDETACHSTATE(&attr, attr_joinable);
-       if (err)
-           croak("panic: pthread_attr_setdetachstate failed");
-#  else
-	croak("panic: can't pthread_attr_setdetachstate");
-#  endif
-    }
-    if (err == 0)
-	err = PTHREAD_CREATE(&thr->self, attr, threadstart, (void*) thr);
-#endif
-
-    if (err) {
-	MUTEX_UNLOCK(&thr->mutex);
-        DEBUG_S(PerlIO_printf(Perl_debug_log,
-			      "%p: create of %p failed %d\n",
-			      savethread, thr, err));
-	/* Thread creation failed--clean up */
-	SvREFCNT_dec(thr->cvcache);
-	remove_thread(aTHX_ thr);
-	for (i = 0; i <= AvFILL(initargs); i++)
-	    SvREFCNT_dec(*av_fetch(initargs, i, FALSE));
-	SvREFCNT_dec(startsv);
-	return NULL;
-    }
-
-#ifdef THREAD_POST_CREATE
-    THREAD_POST_CREATE(thr);
-#else
-    if (sigprocmask(SIG_SETMASK, &oldmask, 0))
-	croak("panic: sigprocmask");
-#endif
-
-    sv = newSViv(thr->tid);
-    sv_magic(sv, thr->oursv, '~', 0, 0);
-    SvMAGIC(sv)->mg_private = Thread_MAGIC_SIGNATURE;
-    sv = sv_bless(newRV_noinc(sv), gv_stashpv(classname, TRUE));
-
-    /* Go */
-    MUTEX_UNLOCK(&thr->mutex);
-
-    return sv;
-#else
-#  ifdef USE_ITHREADS
+#ifdef USE_ITHREADS
     croak("This perl was built for \"ithreads\", which currently does not support Thread.pm.\n"
 	  "Run \"perldoc Thread\" for more information");
-#  else
+#else
     croak("This perl was not built with support for 5.005-style threads.\n"
 	  "Run \"perldoc Thread\" for more information");
-#  endif
-    return &PL_sv_undef;
 #endif
+  return &PL_sv_undef;
 }
 
 static Signal_t handle_thread_signal (int sig);
@@ -369,75 +78,11 @@ join(t)
 	AV *	av = NO_INIT
 	int	i = NO_INIT
     PPCODE:
-#ifdef USE_5005THREADS
-	if (t == thr)
-	    croak("Attempt to join self");
-	DEBUG_S(PerlIO_printf(Perl_debug_log, "%p: joining %p (state %u)\n",
-			      thr, t, ThrSTATE(t)));
-    	MUTEX_LOCK(&t->mutex);
-	switch (ThrSTATE(t)) {
-	case THRf_R_JOINABLE:
-	case THRf_R_JOINED:
-	    ThrSETSTATE(t, THRf_R_JOINED);
-	    MUTEX_UNLOCK(&t->mutex);
-	    break;
-	case THRf_ZOMBIE:
-	    ThrSETSTATE(t, THRf_DEAD);
-	    MUTEX_UNLOCK(&t->mutex);
-	    remove_thread(aTHX_ t);
-	    break;
-	default:
-	    MUTEX_UNLOCK(&t->mutex);
-	    croak("can't join with thread");
-	    /* NOTREACHED */
-	}
-	JOIN(t, &av);
-
-	sv_2mortal((SV*)av);
-
-	if (SvTRUE(*av_fetch(av, 0, FALSE))) {
-	    /* Could easily speed up the following if necessary */
-	    for (i = 1; i <= AvFILL(av); i++)
-		XPUSHs(*av_fetch(av, i, FALSE));
-	}
-	else {
-	    STRLEN n_a;
-	    char *mess = SvPV(*av_fetch(av, 1, FALSE), n_a);
-	    DEBUG_S(PerlIO_printf(Perl_debug_log,
-				  "%p: join propagating die message: %s\n",
-				  thr, mess));
-	    croak(mess);
-	}
-#endif
 
 void
 detach(t)
 	Thread	t
     CODE:
-#ifdef USE_5005THREADS
-	DEBUG_S(PerlIO_printf(Perl_debug_log, "%p: detaching %p (state %u)\n",
-			      thr, t, ThrSTATE(t)));
-    	MUTEX_LOCK(&t->mutex);
-	switch (ThrSTATE(t)) {
-	case THRf_R_JOINABLE:
-	    ThrSETSTATE(t, THRf_R_DETACHED);
-	    /* fall through */
-	case THRf_R_DETACHED:
-	    DETACH(t);
-	    MUTEX_UNLOCK(&t->mutex);
-	    break;
-	case THRf_ZOMBIE:
-	    ThrSETSTATE(t, THRf_DEAD);
-	    DETACH(t);
-	    MUTEX_UNLOCK(&t->mutex);
-	    remove_thread(aTHX_ t);
-	    break;
-	default:
-	    MUTEX_UNLOCK(&t->mutex);
-	    croak("can't detach thread");
-	    /* NOTREACHED */
-	}
-#endif
 
 void
 equal(t1, t2)
@@ -450,17 +95,11 @@ void
 flags(t)
 	Thread	t
     PPCODE:
-#ifdef USE_5005THREADS
-	PUSHs(sv_2mortal(newSViv(t->flags)));
-#endif
 
 void
 done(t)
 	Thread	t
     PPCODE:
-#ifdef USE_5005THREADS
-	PUSHs(t->thr_done ? &PL_sv_yes : &PL_sv_no);
-#endif
 
 void
 self(classname)
@@ -468,25 +107,12 @@ self(classname)
     PREINIT:
 	SV *sv;
     PPCODE:        
-#ifdef USE_5005THREADS
-	sv = newSViv(thr->tid);
-	sv_magic(sv, thr->oursv, '~', 0, 0);
-	SvMAGIC(sv)->mg_private = Thread_MAGIC_SIGNATURE;
-	PUSHs(sv_2mortal(sv_bless(newRV_noinc(sv),
-				  gv_stashpv(classname, TRUE))));
-#endif
 
 U32
 tid(t)
 	Thread	t
     CODE:
-#ifdef USE_5005THREADS
-    	MUTEX_LOCK(&t->mutex);
-	RETVAL = t->tid;
-    	MUTEX_UNLOCK(&t->mutex);
-#else 
 	RETVAL = 0;
-#endif
     OUTPUT:
 	RETVAL
 
@@ -499,138 +125,26 @@ DESTROY(t)
 void
 yield()
     CODE:
-{
-#ifdef USE_5005THREADS
-	YIELD;
-#endif
-}
 
 void
 cond_wait(sv)
 	SV *	sv
-	MAGIC *	mg = NO_INIT
 CODE:                       
-#ifdef USE_5005THREADS
-	if (SvROK(sv))
-	    sv = SvRV(sv);
-
-	mg = condpair_magic(sv);
-	DEBUG_S(PerlIO_printf(Perl_debug_log, "%p: cond_wait %p\n", thr, sv));
-	MUTEX_LOCK(MgMUTEXP(mg));
-	if (MgOWNER(mg) != thr) {
-	    MUTEX_UNLOCK(MgMUTEXP(mg));
-	    croak("cond_wait for lock that we don't own\n");
-	}
-	MgOWNER(mg) = 0;
-	COND_SIGNAL(MgOWNERCONDP(mg));
-	COND_WAIT(MgCONDP(mg), MgMUTEXP(mg));
-	while (MgOWNER(mg))
-	    COND_WAIT(MgOWNERCONDP(mg), MgMUTEXP(mg));
-	MgOWNER(mg) = thr;
-	MUTEX_UNLOCK(MgMUTEXP(mg));
-#endif
 
 void
 cond_signal(sv)
 	SV *	sv
-	MAGIC *	mg = NO_INIT
 CODE:
-#ifdef USE_5005THREADS
-	if (SvROK(sv))
-	    sv = SvRV(sv);
-
-	mg = condpair_magic(sv);
-	DEBUG_S(PerlIO_printf(Perl_debug_log, "%p: cond_signal %p\n",thr,sv));
-	MUTEX_LOCK(MgMUTEXP(mg));
-	if (MgOWNER(mg) != thr) {
-	    MUTEX_UNLOCK(MgMUTEXP(mg));
-	    croak("cond_signal for lock that we don't own\n");
-	}
-	COND_SIGNAL(MgCONDP(mg));
-	MUTEX_UNLOCK(MgMUTEXP(mg));
-#endif
 
 void
 cond_broadcast(sv)
 	SV *	sv
-	MAGIC *	mg = NO_INIT
 CODE: 
-#ifdef USE_5005THREADS
-	if (SvROK(sv))
-	    sv = SvRV(sv);
-
-	mg = condpair_magic(sv);
-	DEBUG_S(PerlIO_printf(Perl_debug_log, "%p: cond_broadcast %p\n",
-			      thr, sv));
-	MUTEX_LOCK(MgMUTEXP(mg));
-	if (MgOWNER(mg) != thr) {
-	    MUTEX_UNLOCK(MgMUTEXP(mg));
-	    croak("cond_broadcast for lock that we don't own\n");
-	}
-	COND_BROADCAST(MgCONDP(mg));
-	MUTEX_UNLOCK(MgMUTEXP(mg));
-#endif
 
 void
 list(classname)
 	char *	classname
-    PREINIT:
-	Thread	t;
-	AV *	av;
-	SV **	svp;
-	int	n = 0;
     PPCODE:
-#ifdef USE_5005THREADS
-	av = newAV();
-	/*
-	 * Iterate until we have enough dynamic storage for all threads.
-	 * We mustn't do any allocation while holding threads_mutex though.
-	 */
-	MUTEX_LOCK(&PL_threads_mutex);
-	do {
-	    n = PL_nthreads;
-	    MUTEX_UNLOCK(&PL_threads_mutex);
-	    if (AvFILL(av) < n - 1) {
-		int i = AvFILL(av);
-		for (i = AvFILL(av); i < n - 1; i++) {
-		    SV *sv = newSViv(0);	/* fill in tid later */
-		    sv_magic(sv, 0, '~', 0, 0);	/* fill in other magic later */
-		    av_push(av, sv_bless(newRV_noinc(sv),
-					 gv_stashpv(classname, TRUE)));
-	
-		}
-	    }
-	    MUTEX_LOCK(&PL_threads_mutex);
-	} while (n < PL_nthreads);
-	n = PL_nthreads;	/* Get the final correct value */
-
-	/*
-	 * At this point, there's enough room to fill in av.
-	 * Note that we are holding threads_mutex so the list
-	 * won't change out from under us but all the remaining
-	 * processing is "fast" (no blocking, malloc etc.)
-	 */
-	t = thr;
-	svp = AvARRAY(av);
-	do {
-	    SV *sv = (SV*)SvRV(*svp);
-	    sv_setiv(sv, t->tid);
-	    SvMAGIC(sv)->mg_obj = SvREFCNT_inc(t->oursv);
-	    SvMAGIC(sv)->mg_flags |= MGf_REFCOUNTED;
-	    SvMAGIC(sv)->mg_private = Thread_MAGIC_SIGNATURE;
-	    t = t->next;
-	    svp++;
-	} while (t != thr);
-	/*  */
-	MUTEX_UNLOCK(&PL_threads_mutex);
-	/* Truncate any unneeded slots in av */
-	av_fill(av, n - 1);
-	/* Finally, push all the new objects onto the stack and drop av */
-	EXTEND(SP, n);
-	for (svp = AvARRAY(av); n > 0; n--, svp++)
-	    PUSHs(*svp);
-	(void)sv_2mortal((SV*)av);
-#endif
 
 
 MODULE = Thread		PACKAGE = Thread::Signal
@@ -672,10 +186,3 @@ void
 data(classname = "Thread::Specific")
 	char *	classname
     PPCODE:
-#ifdef USE_5005THREADS
-	if (AvFILL(thr->specific) == -1) {
-	    GV *gv = gv_fetchpv("Thread::Specific::FIELDS", TRUE, SVt_PVHV);
-	    av_store(thr->specific, 0, newRV((SV*)GvHV(gv)));
-	}
-	XPUSHs(sv_bless(newRV((SV*)thr->specific),gv_stashpv(classname,TRUE)));
-#endif