diff options
author | obrien <obrien@FreeBSD.org> | 2002-02-01 18:16:02 +0000 |
---|---|---|
committer | obrien <obrien@FreeBSD.org> | 2002-02-01 18:16:02 +0000 |
commit | c9ab9ae440a8066b2c2b85b157b1fdadcf09916a (patch) | |
tree | 086d9d6c8fbd4fc8fe4495059332f66bc0f8d12b /contrib/gcc/gthr-solaris.h | |
parent | 2ecfd8bd04b63f335c1ec6295740a4bfd97a4fa6 (diff) | |
download | FreeBSD-src-c9ab9ae440a8066b2c2b85b157b1fdadcf09916a.zip FreeBSD-src-c9ab9ae440a8066b2c2b85b157b1fdadcf09916a.tar.gz |
Enlist the FreeBSD-CURRENT users as testers of what is to become Gcc 3.1.0.
These bits are taken from the FSF anoncvs repo on 1-Feb-2002 08:20 PST.
Diffstat (limited to 'contrib/gcc/gthr-solaris.h')
-rw-r--r-- | contrib/gcc/gthr-solaris.h | 355 |
1 files changed, 329 insertions, 26 deletions
diff --git a/contrib/gcc/gthr-solaris.h b/contrib/gcc/gthr-solaris.h index a6f669c..291210d 100644 --- a/contrib/gcc/gthr-solaris.h +++ b/contrib/gcc/gthr-solaris.h @@ -1,23 +1,23 @@ -/* Threads compatibily routines for libgcc2. */ +/* Threads compatibility routines for libgcc2 and libobjc. */ /* Compile this one with gcc. */ -/* Copyright (C) 1997 Free Software Foundation, Inc. +/* Copyright (C) 1997, 1999, 2000 Free Software Foundation, Inc. -This file is part of GNU CC. +This file is part of GCC. -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. +GCC 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. +GCC 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. */ +along with GCC; 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, @@ -26,12 +26,12 @@ Boston, MA 02111-1307, USA. */ This exception does not however invalidate any other reasons why the executable file might be covered by the GNU General Public License. */ -#ifndef __gthr_solaris_h -#define __gthr_solaris_h +#ifndef GCC_GTHR_SOLARIS_H +#define GCC_GTHR_SOLARIS_H /* 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. */ + know if anyone else implements these. */ #define __GTHREADS 1 @@ -60,13 +60,31 @@ typedef mutex_t __gthread_mutex_t; #pragma weak mutex_trylock #pragma weak mutex_unlock +#ifdef _LIBOBJC +#pragma weak thr_exit +#pragma weak thr_keycreate +#pragma weak thr_getprio +#pragma weak thr_self +#pragma weak thr_setprio +#pragma weak thr_yield + +#pragma weak cond_init +#pragma weak cond_destroy +#pragma weak cond_wait +#pragma weak cond_broadcast +#pragma weak cond_signal + +#pragma weak mutex_init +#pragma weak mutex_destroy +#endif + /* This will not actually work in Solaris 2.5, since libc contains - dummy symbols of all thr_* routines. */ + dummy symbols of all thr_* routines. */ -static void *__gthread_active_ptr = &thr_create; +static void *__gthread_active_ptr = (void *) &thr_create; static inline int -__gthread_active_p () +__gthread_active_p (void) { return __gthread_active_ptr != 0; } @@ -74,15 +92,298 @@ __gthread_active_p () #else /* not SUPPORTS_WEAK */ static inline int -__gthread_active_p () +__gthread_active_p (void) { return 1; } #endif /* SUPPORTS_WEAK */ +#ifdef _LIBOBJC + +/* Key structure for maintaining thread specific storage */ +static thread_key_t _objc_thread_storage; + +/* Thread local storage for a single thread */ +static void *thread_local_storage = NULL; + +/* Backend initialization functions */ + +/* Initialize the threads subsystem. */ +static inline int +__gthread_objc_init_thread_system(void) +{ + /* Initialize the thread storage key */ + if (__gthread_active_p () + && thr_keycreate(&_objc_thread_storage, NULL) == 0) + return 0; + + return -1; +} + +/* Close the threads subsystem. */ +static inline int +__gthread_objc_close_thread_system(void) +{ + if (__gthread_active_p ()) + return 0; + else + return -1; +} + +/* Backend thread functions */ + +/* Create a new thread of execution. */ +static inline objc_thread_t +__gthread_objc_thread_detach(void (*func)(void *), void *arg) +{ + objc_thread_t thread_id; + thread_t new_thread_id = 0; + + if (!__gthread_active_p ()) + return NULL; + + if (thr_create(NULL, 0, (void *)func, arg, + THR_DETACHED | THR_NEW_LWP, + &new_thread_id) == 0) + thread_id = *(objc_thread_t *)&new_thread_id; + else + thread_id = NULL; + + return thread_id; +} + +/* Set the current thread's priority. */ +static inline int +__gthread_objc_thread_set_priority(int priority) +{ + int sys_priority = 0; + + if (!__gthread_active_p ()) + return -1; + + switch (priority) + { + case OBJC_THREAD_INTERACTIVE_PRIORITY: + sys_priority = 300; + break; + default: + case OBJC_THREAD_BACKGROUND_PRIORITY: + sys_priority = 200; + break; + case OBJC_THREAD_LOW_PRIORITY: + sys_priority = 1000; + break; + } + + /* Change priority */ + if (thr_setprio(thr_self(), sys_priority) == 0) + return 0; + else + return -1; +} + +/* Return the current thread's priority. */ +static inline int +__gthread_objc_thread_get_priority(void) +{ + int sys_priority; + + if (!__gthread_active_p ()) + return OBJC_THREAD_INTERACTIVE_PRIORITY; + + if (thr_getprio(thr_self(), &sys_priority) == 0) + { + if (sys_priority >= 250) + return OBJC_THREAD_INTERACTIVE_PRIORITY; + else if (sys_priority >= 150) + return OBJC_THREAD_BACKGROUND_PRIORITY; + return OBJC_THREAD_LOW_PRIORITY; + } + + /* Couldn't get priority. */ + return -1; +} + +/* Yield our process time to another thread. */ +static inline void +__gthread_objc_thread_yield(void) +{ + if (__gthread_active_p ()) + thr_yield(); +} + +/* Terminate the current thread. */ +static inline int +__gthread_objc_thread_exit(void) +{ + if (__gthread_active_p ()) + /* exit the thread */ + thr_exit(&__objc_thread_exit_status); + + /* Failed if we reached here */ + return -1; +} + +/* Returns an integer value which uniquely describes a thread. */ +static inline objc_thread_t +__gthread_objc_thread_id(void) +{ + if (__gthread_active_p ()) + return (objc_thread_t)thr_self(); + else + return (objc_thread_t)1; +} + +/* Sets the thread's local storage pointer. */ static inline int -__gthread_once (__gthread_once_t *once, void (*func) ()) +__gthread_objc_thread_set_data(void *value) +{ + if (__gthread_active_p ()) + { + if (thr_setspecific(_objc_thread_storage, value) == 0) + return 0; + else + return -1; + } + else + { + thread_local_storage = value; + return 0; + } +} + +/* Returns the thread's local storage pointer. */ +static inline void * +__gthread_objc_thread_get_data(void) +{ + void *value = NULL; + + if (__gthread_active_p ()) + { + if (thr_getspecific(_objc_thread_storage, &value) == 0) + return value; + else + return NULL; + } + else + return thread_local_storage; +} + +/* Backend mutex functions */ + +/* Allocate a mutex. */ +static inline int +__gthread_objc_mutex_allocate(objc_mutex_t mutex) +{ + if (__gthread_active_p () + && mutex_init( (mutex_t *)(&(mutex->backend)), USYNC_THREAD, 0)) + return -1; + + return 0; +} + +/* Deallocate a mutex. */ +static inline int +__gthread_objc_mutex_deallocate(objc_mutex_t mutex) +{ + if (__gthread_active_p ()) + mutex_destroy((mutex_t *)(&(mutex->backend))); + + return 0; +} + +/* Grab a lock on a mutex. */ +static inline int +__gthread_objc_mutex_lock(objc_mutex_t mutex) +{ + if (__gthread_active_p () + && mutex_lock((mutex_t *)(&(mutex->backend))) != 0) + return -1; + + return 0; +} + +/* Try to grab a lock on a mutex. */ +static inline int +__gthread_objc_mutex_trylock(objc_mutex_t mutex) +{ + if (__gthread_active_p () + && mutex_trylock((mutex_t *)(&(mutex->backend))) != 0) + return -1; + + return 0; +} + +/* Unlock the mutex */ +static inline int +__gthread_objc_mutex_unlock(objc_mutex_t mutex) +{ + if (__gthread_active_p () + && mutex_unlock((mutex_t *)(&(mutex->backend))) != 0) + return -1; + + return 0; +} + +/* Backend condition mutex functions */ + +/* Allocate a condition. */ +static inline int +__gthread_objc_condition_allocate(objc_condition_t condition) +{ + if (__gthread_active_p ()) + return cond_init((cond_t *)(&(condition->backend)), USYNC_THREAD, + NULL); + else + return 0; +} + +/* Deallocate a condition. */ +static inline int +__gthread_objc_condition_deallocate(objc_condition_t condition) +{ + if (__gthread_active_p ()) + return cond_destroy((cond_t *)(&(condition->backend))); + else + return 0; +} + +/* Wait on the condition */ +static inline int +__gthread_objc_condition_wait(objc_condition_t condition, objc_mutex_t mutex) +{ + if (__gthread_active_p ()) + return cond_wait((cond_t *)(&(condition->backend)), + (mutex_t *)(&(mutex->backend))); + else + return 0; +} + +/* Wake up all threads waiting on this condition. */ +static inline int +__gthread_objc_condition_broadcast(objc_condition_t condition) +{ + if (__gthread_active_p ()) + return cond_broadcast((cond_t *)(&(condition->backend))); + else + return 0; +} + +/* Wake up one thread waiting on this condition. */ +static inline int +__gthread_objc_condition_signal(objc_condition_t condition) +{ + if (__gthread_active_p ()) + return cond_signal((cond_t *)(&(condition->backend))); + else + return 0; +} + +#else /* _LIBOBJC */ + +static inline int +__gthread_once (__gthread_once_t *once, void (*func) (void)) { if (! __gthread_active_p ()) return -1; @@ -109,7 +410,7 @@ static inline int __gthread_key_create (__gthread_key_t *key, void (*dtor) (void *)) { /* Solaris 2.5 contains thr_* routines no-op in libc, so test if we actually - got a reasonable key value, and if not, fail. */ + got a reasonable key value, and if not, fail. */ *key = -1; if (thr_keycreate (key, dtor) != 0 || *key == -1) return -1; @@ -120,14 +421,14 @@ __gthread_key_create (__gthread_key_t *key, void (*dtor) (void *)) static inline int __gthread_key_dtor (__gthread_key_t key, void *ptr) { - /* Nothing needed. */ + /* Nothing needed. */ return 0; } static inline int __gthread_key_delete (__gthread_key_t key) { - /* Not possible. */ + /* Not possible. */ return -1; } @@ -174,4 +475,6 @@ __gthread_mutex_unlock (__gthread_mutex_t *mutex) return 0; } -#endif /* not __gthr_solaris_h */ +#endif /* _LIBOBJC */ + +#endif /* ! GCC_GTHR_SOLARIS_H */ |