OpenE2K
/
gcc
2
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Thread-safe EH support for pthreads, DCE threads and Solaris threads. 

Thu Dec 11 20:42:18 1997  Teemu Torma  <tot@trema.com>

	Thread-safe EH support for pthreads, DCE threads and Solaris threads.

	* integrate.c (expand_inline_function): If the inline fn uses eh
	context, make sure that the current fn has one.
	* toplev.c (rest_of_compilation): Call emit_eh_context.
	* except.c (use_eh_context): New fn.
	(get_eh_context_once): New fn.
	(call_get_eh_context): New fn.
	(emit_eh_context): New fn.
	(get_eh_context): Call either get_eh_context_once or
	call_get_eh_context, depending on what we have.
	(get_dynamic_handler_chain): Call get_eh_context_once.
	* except.h: Prototypes for fns above.
	* optabs.c (get_eh_context_libfunc): Removed.
	(init_optabs): Don't initialize it.
	* expr.h (get_eh_context_libfunc): Removed.
	* rtl.h, rtl.c: New reg_note REG_EH_CONTEXT.
	* config/pa/pa.h (CPP_SPEC): Support for -threads.
	* config/pa/pa-hpux10.h (LIB_SPEC): Ditto.
	* config/pa/t-pa (MULTILIB_OPTIONS, MULTILIB_DIRNAMES):
	New multilib for -threads.
	* config/sparc/t-sol2: Added multilibs for -threads and
	made -pthreads alias to it.
	* config/sparc/sol2.h (CPP_SPEC, LIB_SPEC):
	Added -threads and -pthreads options.
	* libgcc-thr.h: New file.
	* libgcc2.c: (__get_cpp_eh_context): Removed.
	(struct cpp_eh_context): Removed.
	(struct eh_context): Replaced cpp_eh_context with generic language
	specific pointer.
	(__get_eh_info): New function.
	(__throw): Check eh_context::info.
	(__sjthrow): Ditto.
	* libgcc2.c: Include libgcc-thr.h.
	(new_eh_context, __get_eh_context,
	eh_pthread_initialize, eh_context_initialize, eh_context_static,
	eh_context_specific, eh_context_free): New functions.
	(get_eh_context, eh_context_key): New variables.
	(__sjthrow, __sjpopnthrow, __eh_pcnthrow, __throw): Use
	get_eh_context to get the context.
	(longjmp): Move the declaration inside
	#ifdef DONT_USE_BUILTIN_SETJMP.
	* frame.c: Include libgcc-thr.h.
	(object_mutex): Mutex to protect the object list.
	(find_fde, __register_frame, __register_frame_table,
	__deregister_frame): Hold the lock while accessing objects.
	* except.h (get_eh_context): Declare.
	* except.c (current_function_ehc): Define.
	(current_function_dhc, current_function_dcc): Removed.
	(get_eh_context): New function.
	(get_dynamic_handler_chain): Use get_eh_context.
	(get_saved_pc_ref): Ditto.
	(get_dynamic_cleanup_chain): Removed references to
	current_function_dcc.
	(save_eh_status, restore_eh_status): Save and restore
	current_function_ehc instead.
	* optabs.c (get_eh_context_libfunc): New variable.
	(init_optabs): Initialize it.
	* expr.h: Declare get_eh_context_libfunc.
	* function.h (struct function): Replaced dhc and dcc with ehc.
	* except.c (get_saved_pc_ref): New functions.
	(eh_saved_pc_rtx, eh_saved_pc): Deleted.
	(expand_internal_throw_indirect): Use get_saved_pc_ref() instead
	of eh_saved_pc.
	(end_eh_unwinder): Likewise.
	(init_eh): Remove initialization of eh_saved_pc.
	* optabs.c (get_saved_pc_libfunc): New variable.
	(init_optabs): Initialize it.
	* expr.h: Declare get_saved_pc_libfunc.
	* except.h (eh_saved_pc_rtx): Deleted.
	(get_saved_pc_ref): Declared.

	From Scott Snyder <snyder@d0sgif.fnal.gov>:
	* libgcc2.c (__get_saved_pc): New.
	(__eh_type, __eh_pc): Deleted.
	(__eh_pcnthrow): Use __get_saved_pc() instead of __eh_pc.
	(__get_dynamic_handler_chain): Move __dynamic_handler_chain inside
	this fcn.

From-SVN: r17053
This commit is contained in:
Teemu Torma 1997-12-11 23:54:37 -05:00 committed by Jason Merrill
parent 154bba13a4
commit c404fea226
1 changed files with 321 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

321
gcc/libgcc-thr.h Normal file
View File

@ -0,0 +1,321 @@
/* Threads compatibily routines for libgcc2. */
/* Compile this one with gcc. */
/* Copyright (C) 1997 Free Software Foundation, Inc.
This file is part of GNU CC.
GNU CC is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2, or (at your option)
any later version.
GNU CC is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with GNU CC; see the file COPYING. If not, write to
the Free Software Foundation, 59 Temple Place - Suite 330,
Boston, MA 02111-1307, USA. */
/* As a special exception, if you link this library with other files,
some of which are compiled with GCC, to produce an executable,
this library does not by itself cause the resulting executable
to be covered by the GNU General Public License.
This exception does not however invalidate any other reasons why
the executable file might be covered by the GNU General Public License. */
#ifndef __libgcc_thr_h
#define __libgcc_thr_h
/* If this file is compiled with threads support, it must
#define __GTHREADS 1
to indicate that threads support is present.
The threads interface must define the following types:
__gthread_key_t
__gthread_once_t
__gthread_mutex_t
The threads interface must define the following macros:
__GTHREAD_ONCE_INIT
to initialize __gthread_once_t
__GTHREAD_MUTEX_INIT
to initialize __gthread_mutex_t to get a fast
non-recursive mutex.
The threads interface must define the following static functions:
int __gthread_once (__gthread_once_t *once, void (*func) ())
int __gthread_key_create (__gthread_key_t *keyp, void (*dtor) (void *))
int __gthread_key_delete (__gthread_key_t key)
void *__gthread_getspecific (__gthread_key_t key)
int __gthread_setspecific (__gthread_key_t key, const void *ptr)
int __gthread_mutex_lock (__gthread_mutex_t *mutex);
int __gthread_mutex_trylock (__gthread_mutex_t *mutex);
int __gthread_mutex_unlock (__gthread_mutex_t *mutex);
All functions returning int should return 0 on success, -1 on error.
Currently supported threads packages are
POSIX threads with -D_PTHREADS
DCE threads with -D_DCE_THREADS
Solaris/UI threads with -D_SOLARIS_THREADS
*/
#if _PTHREADS
/* POSIX threads specific definitions.
Easy, since the interface is just one-to-one mapping. */
#define __GTHREADS 1
#include <pthread.h>
typedef pthread_key_t __gthread_key_t;
typedef pthread_once_t __gthread_once_t;
typedef pthread_mutex_t __gthread_mutex_t;
#define __GTHREAD_MUTEX_INIT PTHREAD_MUTEX_INITIALIZER
#define __GTHREAD_ONCE_INIT PTHREAD_ONCE_INIT
static inline int
__gthread_once (__gthread_once_t *once, void (*func) ())
{
return pthread_once (once, func);
}
static inline int
__gthread_key_create (__gthread_key_t *key, void (*dtor) (void *))
{
return pthread_key_create (key, dtor);
}
static inline int
__gthread_key_delete (__gthread_key_t key)
{
return pthread_key_delete (key);
}
static inline void *
__gthread_getspecific (__gthread_key_t key)
{
return pthread_getspecific (key);
}
static inline int
__gthread_setspecific (__gthread_key_t key, const void *ptr)
{
return pthread_setspecific (key, ptr);
}
static inline int
__gthread_mutex_lock (__gthread_mutex_t *mutex)
{
return pthread_mutex_lock (mutex);
}
static inline int
__gthread_mutex_trylock (__gthread_mutex_t *mutex)
{
return pthread_mutex_trylock (mutex);
}
static inline int
__gthread_mutex_unlock (__gthread_mutex_t *mutex)
{
return pthread_mutex_unlock (mutex);
}
#elif _DCE_THREADS
/* DCE threads interface.
DCE threads are based on POSIX threads draft 4, and many things
have changed since then. */
#define __GTHREADS 1
#include <pthread.h>
typedef pthread_key_t __gthread_key_t;
typedef pthread_once_t __gthread_once_t;
typedef pthread_mutex_t __gthread_mutex_t;
#define __GTHREAD_ONCE_INIT pthread_once_init
/* Howto define __GTHREAD_MUTEX_INIT? */
static inline int
__gthread_once (__gthread_once_t *once, void (*func) ())
{
return pthread_once (once, func);
}
static inline int
__gthread_key_create (__gthread_key_t *key, void (*dtor) (void *))
{
return pthread_keycreate (key, dtor);
}
static inline int
__gthread_key_delete (__gthread_key_t key)
{
return pthread_key_delete (key);
}
static inline void *
__gthread_getspecific (__gthread_key_t key)
{
void *ptr;
if (pthread_getspecific (key, &ptr) == 0)
return ptr;
else
return 0;
}
static inline int
__gthread_setspecific (__gthread_key_t key, const void *ptr)
{
return pthread_setspecific (key, (void *) ptr);
}
static inline int
__gthread_mutex_lock (__gthread_mutex_t *mutex)
{
return pthread_mutex_lock (mutex);
}
static inline int
__gthread_mutex_trylock (__gthread_mutex_t *mutex)
{
return pthread_mutex_trylock (mutex);
}
static inline int
__gthread_mutex_unlock (__gthread_mutex_t *mutex)
{
return pthread_mutex_unlock (mutex);
}
#elif _SOLARIS_THREADS
/* Solaris threads as found in Solaris 2.[456].
Actually these are Unix International (UI) threads, but I don't
know if anyone else implements these. */
#define __GTHREADS 1
#include <thread.h>
#include <errno.h>
typedef thread_key_t __gthread_key_t;
typedef struct
{
mutex_t mutex;
int once;
} __gthread_once_t;
typedef mutex_t __gthread_mutex_t;
#define __GTHREAD_ONCE_INIT { DEFAULTMUTEX, 0 }
#define __GTHREAD_MUTEX_INIT DEFAULTMUTEX
static inline int
__gthread_once (__gthread_once_t *once, void (*func) ())
{
if (once == 0 || func == 0)
{
errno = EINVAL;
return -1;
}
if (once->once == 0)
{
if (mutex_lock (&once->mutex) != 0)
return -1;
if (once->once == 0)
{
(*func) ();
once->once ++;
}
mutex_unlock (&once->mutex);
}
return 0;
}
static inline int
__gthread_key_create (__gthread_key_t *key, void (*dtor) (void *))
{
return thr_keycreate (key, dtor);
}
static inline int
__gthread_key_delete (__gthread_key_t key)
{
/* Not possible. */
return -1;
}
static inline void *
__gthread_getspecific (__gthread_key_t key)
{
void *ptr;
if (thr_getspecific (key, &ptr) == 0)
return ptr;
else
return 0;
}
static inline int
__gthread_setspecific (__gthread_key_t key, const void *ptr)
{
return thr_setspecific (key, (void *) ptr);
}
static inline int
__gthread_mutex_lock (__gthread_mutex_t *mutex)
{
return mutex_lock (mutex);
}
static inline int
__gthread_mutex_trylock (__gthread_mutex_t *mutex)
{
return mutex_trylock (mutex);
}
static inline int
__gthread_mutex_unlock (__gthread_mutex_t *mutex)
{
return mutex_unlock (mutex);
}
#else /* no threads */
/* Just provide compatibility for mutex handling. */
typedef int __gthread_mutex_t;
#define __GTHREAD_MUTEX_INIT 0
static inline int
__gthread_mutex_lock (__gthread_mutex_t *mutex)
{
return 0;
}
static inline int
__gthread_mutex_trylock (__gthread_mutex_t *mutex)
{
return 0;
}
static inline int
__gthread_mutex_unlock (__gthread_mutex_t *mutex)
{
return 0;
}
#endif /* no threads */
#endif /* not __libgcc_thr_h */