From c404fea2260f6bd4eacecdcf3642da6fd67dae89 Mon Sep 17 00:00:00 2001 From: Teemu Torma Date: Thu, 11 Dec 1997 23:54:37 -0500 Subject: [PATCH] Thread-safe EH support for pthreads, DCE threads and Solaris threads. Thu Dec 11 20:42:18 1997 Teemu Torma 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 : * 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 --- gcc/libgcc-thr.h | 321 +++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 321 insertions(+) create mode 100644 gcc/libgcc-thr.h diff --git a/gcc/libgcc-thr.h b/gcc/libgcc-thr.h new file mode 100644 index 00000000000..53813c5c789 --- /dev/null +++ b/gcc/libgcc-thr.h @@ -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 + +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 + +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 +#include + +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 */