+2019-11-12 Corentin Gay <gay@adacore.com>
+ Jerome Lambourg <lambourg@adacore.com>
+ Olivier Hainque <hainque@adacore.com>
+
+ * config/t-gthr-vxworks: New file, add all the gthr-vxworks
+ sources to LIB2ADDEH.
+ * config/t-vxworks: Remove adjustments to LIB2ADDEH.
+ * config/t-vxworks7: Likewise.
+
+ * config.host: Append a block at the end of the file to add the
+ t-gthr files to the tmake_file list for VxWorks after everything
+ else.
+
+ * config/vxlib.c: Rename as gthr-vxworks.c.
+ * config/vxlib-tls.c: Rename as gthr-vxworks-tls.c.
+
+ * config/gthr-vxworks.h: Simplify a few comments. Expose a TAS
+ API and a basic error checking API, both internal. Simplify the
+ __gthread_once_t type definition and initializers. Add sections
+ for condition variables support and for the C++0x thread support,
+ conditioned against Vx653 for the latter.
+
+ * config/gthr-vxworks.c (__gthread_once): Simplify comments and
+ implementation, leveraging the TAS internal API.
+ * config/gthr-vxworks-tls.c: Introduce an internal TLS data access
+ API, leveraging the general availability of TLS services in VxWorks7
+ post SR6xxx.
+ (__gthread_setspecific, __gthread_setspecific): Use it.
+ (tls_delete_hook): Likewise, and simplify the enter/leave dtor logic.
+ * config/gthr-vxworks-cond.c: New file. GTHREAD_COND variable
+ support based on VxWorks primitives.
+ * config/gthr-vxworks-thread.c: New file. GTHREAD_CXX0X support
+ based on VxWorks primitives.
+
2019-11-06 Jerome Lambourg <lambourg@adacore.com>
Olivier Hainque <hainque@adacore.com>
tm_file="${tm_file} aarch64/value-unwind.h"
;;
esac
+
+# The vxworks threads implementation relies on a few extra sources,
+# which we arrange to add after everything else:
+
+case ${target_thread_file} in
+vxworks)
+ case ${host} in
+ *-*-vxworks*)
+ tmake_file="${tmake_file} t-gthr-vxworks"
+ ;;
+ esac
+esac
--- /dev/null
+/* Copyright (C) 2002-2019 Free Software Foundation, Inc.
+
+This file is part of GCC.
+
+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 3, or (at your option) any later
+version.
+
+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.
+
+Under Section 7 of GPL version 3, you are granted additional
+permissions described in the GCC Runtime Library Exception, version
+3.1, as published by the Free Software Foundation.
+
+You should have received a copy of the GNU General Public License and
+a copy of the GCC Runtime Library Exception along with this program;
+see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
+<http://www.gnu.org/licenses/>. */
+
+/* Threads compatibility routines for libgcc2 for VxWorks.
+
+ This file implements the GTHREAD_HAS_COND part of the interface
+ exposed by gthr-vxworks.h. */
+
+#include "gthr.h"
+#include <taskLib.h>
+
+/* --------------------------- Condition Variables ------------------------ */
+
+void
+__gthread_cond_init (__gthread_cond_t *cond)
+{
+ if (!cond)
+ return;
+ *cond = semBCreate (SEM_Q_FIFO, SEM_EMPTY);
+}
+
+int
+__gthread_cond_destroy (__gthread_cond_t *cond)
+{
+ if (!cond)
+ return ERROR;
+ return __CHECK_RESULT (semDelete (*cond));
+}
+
+int
+__gthread_cond_broadcast (__gthread_cond_t *cond)
+{
+ if (!cond)
+ return ERROR;
+
+ return __CHECK_RESULT (semFlush (*cond));
+}
+
+int
+__gthread_cond_wait (__gthread_cond_t *cond,
+ __gthread_mutex_t *mutex)
+{
+ if (!cond)
+ return ERROR;
+
+ if (!mutex)
+ return ERROR;
+
+ __RETURN_ERRNO_IF_NOT_OK (semGive (*mutex));
+
+ __RETURN_ERRNO_IF_NOT_OK (semTake (*cond, WAIT_FOREVER));
+
+ __RETURN_ERRNO_IF_NOT_OK (semTake (*mutex, WAIT_FOREVER));
+
+ return OK;
+}
+
+int
+__gthread_cond_wait_recursive (__gthread_cond_t *cond,
+ __gthread_recursive_mutex_t *mutex)
+{
+ return __gthread_cond_wait (cond, mutex);
+}
--- /dev/null
+/* Copyright (C) 2002-2019 Free Software Foundation, Inc.
+
+This file is part of GCC.
+
+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 3, or (at your option) any later
+version.
+
+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.
+
+Under Section 7 of GPL version 3, you are granted additional
+permissions described in the GCC Runtime Library Exception, version
+3.1, as published by the Free Software Foundation.
+
+You should have received a copy of the GNU General Public License and
+a copy of the GCC Runtime Library Exception along with this program;
+see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
+<http://www.gnu.org/licenses/>. */
+
+/* Threads compatibility routines for libgcc2 for VxWorks.
+
+ This file implements the GTHREAD_CXX0X part of the interface
+ exposed by gthr-vxworks.h, using APIs exposed by regular (!AE/653)
+ VxWorks kernels. */
+
+#include "gthr.h"
+#include <taskLib.h>
+
+#define __TIMESPEC_TO_NSEC(timespec) \
+ ((long long)timespec.tv_sec * 1000000000 + (long long)timespec.tv_nsec)
+
+#define __TIMESPEC_TO_TICKS(timespec) \
+ ((long long)(sysClkRateGet() * __TIMESPEC_TO_NSEC(timespec) + 999999999) \
+ / 1000000000)
+
+#ifdef __RTP__
+ void tls_delete_hook ();
+ #define __CALL_DELETE_HOOK(tcb) tls_delete_hook()
+#else
+ /* In kernel mode, we need to pass the TCB to task_delete_hook. The TCB is
+ the pointer to the WIND_TCB structure and is the ID of the task. */
+ void tls_delete_hook (void *TCB);
+ #define __CALL_DELETE_HOOK(tcb) tls_delete_hook((WIND_TCB *) ((tcb)->task_id))
+#endif
+
+/* -------------------- Timed Condition Variables --------------------- */
+
+int
+__gthread_cond_signal (__gthread_cond_t *cond)
+{
+ if (!cond)
+ return ERROR;
+
+ return __CHECK_RESULT (semGive (*cond));
+}
+
+int
+__gthread_cond_timedwait (__gthread_cond_t *cond,
+ __gthread_mutex_t *mutex,
+ const __gthread_time_t *abs_timeout)
+{
+ if (!cond)
+ return ERROR;
+
+ if (!mutex)
+ return ERROR;
+
+ if (!abs_timeout)
+ return ERROR;
+
+ struct timespec current;
+ if (clock_gettime (CLOCK_REALTIME, ¤t) == ERROR)
+ /* CLOCK_REALTIME is not supported. */
+ return ERROR;
+
+ const long long abs_timeout_ticks = __TIMESPEC_TO_TICKS ((*abs_timeout));
+ const long long current_ticks = __TIMESPEC_TO_TICKS (current);
+
+ long long waiting_ticks;
+
+ if (current_ticks < abs_timeout_ticks)
+ waiting_ticks = abs_timeout_ticks - current_ticks;
+ else
+ /* The point until we would need to wait is in the past,
+ no need to wait at all. */
+ waiting_ticks = 0;
+
+ /* We check that waiting_ticks can be safely casted as an int. */
+ if (waiting_ticks > INT_MAX)
+ waiting_ticks = INT_MAX;
+
+ __RETURN_ERRNO_IF_NOT_OK (semGive (*mutex));
+
+ __RETURN_ERRNO_IF_NOT_OK (semTake (*cond, waiting_ticks));
+
+ __RETURN_ERRNO_IF_NOT_OK (semTake (*mutex, WAIT_FOREVER));
+
+ return OK;
+}
+
+/* --------------------------- Timed Mutexes ------------------------------ */
+
+int
+__gthread_mutex_timedlock (__gthread_mutex_t *m,
+ const __gthread_time_t *abs_time)
+{
+ if (!m)
+ return ERROR;
+
+ if (!abs_time)
+ return ERROR;
+
+ struct timespec current;
+ if (clock_gettime (CLOCK_REALTIME, ¤t) == ERROR)
+ /* CLOCK_REALTIME is not supported. */
+ return ERROR;
+
+ const long long abs_timeout_ticks = __TIMESPEC_TO_TICKS ((*abs_time));
+ const long long current_ticks = __TIMESPEC_TO_TICKS (current);
+ long long waiting_ticks;
+
+ if (current_ticks < abs_timeout_ticks)
+ waiting_ticks = abs_timeout_ticks - current_ticks;
+ else
+ /* The point until we would need to wait is in the past,
+ no need to wait at all. */
+ waiting_ticks = 0;
+
+ /* Make sure that waiting_ticks can be safely casted as an int. */
+ if (waiting_ticks > INT_MAX)
+ waiting_ticks = INT_MAX;
+
+ return __CHECK_RESULT (semTake (*m, waiting_ticks));
+}
+
+int
+__gthread_recursive_mutex_timedlock (__gthread_recursive_mutex_t *mutex,
+ const __gthread_time_t *abs_timeout)
+{
+ return __gthread_mutex_timedlock ((__gthread_mutex_t *)mutex, abs_timeout);
+}
+
+/* ------------------------------ Threads --------------------------------- */
+
+/* Task control block initialization and destruction functions. */
+
+int
+__init_gthread_tcb (__gthread_t __tcb)
+{
+ if (!__tcb)
+ return ERROR;
+
+ __gthread_mutex_init (&(__tcb->return_value_available));
+ if (__tcb->return_value_available == SEM_ID_NULL)
+ return ERROR;
+
+ __gthread_mutex_init (&(__tcb->delete_ok));
+ if (__tcb->delete_ok == SEM_ID_NULL)
+ goto return_sem_delete;
+
+ /* We lock the two mutexes used for signaling. */
+ if (__gthread_mutex_lock (&(__tcb->delete_ok)) != OK)
+ goto delete_sem_delete;
+
+ if (__gthread_mutex_lock (&(__tcb->return_value_available)) != OK)
+ goto delete_sem_delete;
+
+ __tcb->task_id = TASK_ID_NULL;
+ return OK;
+
+delete_sem_delete:
+ semDelete (__tcb->delete_ok);
+return_sem_delete:
+ semDelete (__tcb->return_value_available);
+ return ERROR;
+}
+
+/* Here, we pass a pointer to a tcb to allow calls from
+ cleanup attributes. */
+void
+__delete_gthread_tcb (__gthread_t* __tcb)
+{
+ semDelete ((*__tcb)->return_value_available);
+ semDelete ((*__tcb)->delete_ok);
+ free (*__tcb);
+}
+
+/* This __gthread_t stores the address of the TCB malloc'ed in
+ __gthread_create. It is then accessible via __gthread_self(). */
+__thread __gthread_t __local_tcb = NULL;
+
+__gthread_t
+__gthread_self (void)
+{
+ if (!__local_tcb)
+ {
+ /* We are in the initial thread, we need to initialize the TCB. */
+ __local_tcb = malloc (sizeof (*__local_tcb));
+ if (!__local_tcb)
+ return NULL;
+
+ if (__init_gthread_tcb (__local_tcb) != OK)
+ {
+ __delete_gthread_tcb (&__local_tcb);
+ return NULL;
+ }
+ /* We do not set the mutexes in the structure as a thread is not supposed
+ to join or detach himself. */
+ __local_tcb->task_id = taskIdSelf ();
+ }
+ return __local_tcb;
+}
+
+int
+__task_wrapper (__gthread_t tcb, FUNCPTR __func, _Vx_usr_arg_t __args)
+{
+ if (!tcb)
+ return ERROR;
+
+ __local_tcb = tcb;
+
+ /* We use this variable to avoid memory leaks in the case where
+ the underlying function throws an exception. */
+ __attribute__ ((cleanup (__delete_gthread_tcb))) __gthread_t __tmp = tcb;
+
+ void *return_value = (void *) __func (__args);
+ tcb->return_value = return_value;
+
+ /* Call the destructors. */
+ __CALL_DELETE_HOOK (tcb);
+
+ /* Future calls of join() will be able to retrieve the return value. */
+ __gthread_mutex_unlock (&tcb->return_value_available);
+
+ /* We wait for the thread to be joined or detached. */
+ __gthread_mutex_lock (&(tcb->delete_ok));
+ __gthread_mutex_unlock (&(tcb->delete_ok));
+
+ /* Memory deallocation is done by the cleanup attribute of the tmp variable. */
+
+ return OK;
+}
+
+/* Proper gthreads API. */
+
+int
+__gthread_create (__gthread_t * __threadid, void *(*__func) (void *),
+ void *__args)
+{
+ if (!__threadid)
+ return ERROR;
+
+ int priority;
+ __RETURN_ERRNO_IF_NOT_OK (taskPriorityGet (taskIdSelf (), &priority));
+
+ int options;
+ __RETURN_ERRNO_IF_NOT_OK (taskOptionsGet (taskIdSelf (), &options));
+
+#if defined (__SPE__)
+ options |= VX_SPE_TASK;
+#else
+ options |= VX_FP_TASK;
+#endif
+ options &= VX_USR_TASK_OPTIONS;
+
+ int stacksize = 20 * 1024;
+
+ __gthread_t tcb = malloc (sizeof (*tcb));
+ if (!tcb)
+ return ERROR;
+
+ if (__init_gthread_tcb (tcb) != OK)
+ {
+ free (tcb);
+ return ERROR;
+ }
+
+ TASK_ID task_id = taskCreate (NULL,
+ priority, options, stacksize,
+ (FUNCPTR) & __task_wrapper,
+ (_Vx_usr_arg_t) tcb,
+ (_Vx_usr_arg_t) __func,
+ (_Vx_usr_arg_t) __args,
+ 0, 0, 0, 0, 0, 0, 0);
+
+ /* If taskCreate succeeds, task_id will be a valid TASK_ID and not zero. */
+ __RETURN_ERRNO_IF_NOT_OK (!task_id);
+
+ tcb->task_id = task_id;
+ *__threadid = tcb;
+
+ return __CHECK_RESULT (taskActivate (task_id));
+}
+
+int
+__gthread_equal (__gthread_t __t1, __gthread_t __t2)
+{
+ return (__t1 == __t2) ? OK : ERROR;
+}
+
+int
+__gthread_yield (void)
+{
+ return taskDelay (0);
+}
+
+int
+__gthread_join (__gthread_t __threadid, void **__value_ptr)
+{
+ if (!__threadid)
+ return ERROR;
+
+ /* A thread cannot join itself. */
+ if (__threadid->task_id == taskIdSelf ())
+ return ERROR;
+
+ /* Waiting for the task to set the return value. */
+ __gthread_mutex_lock (&__threadid->return_value_available);
+ __gthread_mutex_unlock (&__threadid->return_value_available);
+
+ if (__value_ptr)
+ *__value_ptr = __threadid->return_value;
+
+ /* The task will be safely be deleted. */
+ __gthread_mutex_unlock (&(__threadid->delete_ok));
+
+ __RETURN_ERRNO_IF_NOT_OK (taskWait (__threadid->task_id, WAIT_FOREVER));
+
+ return OK;
+}
+
+int
+__gthread_detach (__gthread_t __threadid)
+{
+ if (!__threadid)
+ return ERROR;
+
+ if (taskIdVerify (__threadid->task_id) != OK)
+ return ERROR;
+
+ /* The task will be safely be deleted. */
+ __gthread_mutex_unlock (&(__threadid->delete_ok));
+
+ return OK;
+}
-/* Copyright (C) 2002-2019 Free Software Foundation, Inc.
+/* Copyright (C) 2002-2018 Free Software Foundation, Inc.
Contributed by Zack Weinberg <zack@codesourcery.com>
This file is part of GCC.
<http://www.gnu.org/licenses/>. */
/* Threads compatibility routines for libgcc2 for VxWorks.
- These are out-of-line routines called from gthr-vxworks.h.
+ These are out-of-line routines called from gthr-vxworks.h.
This file provides the TLS related support routines, calling specific
- VxWorks kernel entry points for this purpose. The base VxWorks 5.x kernels
- don't feature these entry points, and we provide gthr_supp_vxw_5x.c as an
- option to fill this gap. Asking users to rebuild a kernel is not to be
- taken lightly, still, so we have isolated these routines from the rest of
- vxlib to ensure that the kernel dependencies are only dragged when really
- necessary. */
+ VxWorks kernel entry points for this purpose. */
#include "tconfig.h"
#include "tsystem.h"
#include "gthr.h"
#if defined(__GTHREADS)
+
#include <vxWorks.h>
#ifndef __RTP__
#include <vxLib.h>
#ifndef __RTP__
#include <taskHookLib.h>
#else
-# include <errno.h>
+#include <errno.h>
#endif
/* Thread-local storage.
- We reserve a field in the TCB to point to a dynamically allocated
- array which is used to store TLS values. A TLS key is simply an
- offset in this array. The exact location of the TCB field is not
- known to this code nor to vxlib.c -- all access to it indirects
- through the routines __gthread_get_tls_data and
- __gthread_set_tls_data, which are provided by the VxWorks kernel.
+ A gthread TLS key is simply an offset in an array, the address of which
+ we store in a single pointer field associated with the current task.
+
+ On VxWorks 7, we have direct support for __thread variables and use
+ such a variable as the pointer "field". On other versions, we resort
+ to __gthread_get_tls_data and __gthread_set_tls_data functions provided
+ by the kernel.
There is also a global array which records which keys are valid and
which have destructors.
- A task delete hook is installed to execute key destructors. The
- routines __gthread_enter_tls_dtor_context and
- __gthread_leave_tls_dtor_context, which are also provided by the
- kernel, ensure that it is safe to call free() on memory allocated
- by the task being deleted. (This is a no-op on VxWorks 5, but
- a major undertaking on AE.)
+ A task delete hook is installed to execute key destructors. The routines
+ __gthread_enter_tls_dtor_context and __gthread_leave_tls_dtor_context,
+ which are also provided by the kernel, ensure that it is safe to call
+ free() on memory allocated by the task being deleted. This is a no-op on
+ VxWorks 5, but a major undertaking on AE.
The task delete hook is only installed when at least one thread
has TLS data. This is a necessary precaution, to allow this module
- to be unloaded - a module with a hook cannot be removed.
+ to be unloaded - a module with a hook can not be removed.
Since this interface is used to allocate only a small number of
keys, the table size is small and static, which simplifies the
it is only removed when unloading this module. */
static volatile int delete_hook_installed;
-/* kernel provided routines */
+/* TLS data access internal API. A straight __thread variable on VxWorks 7,
+ a pointer returned by kernel provided routines otherwise. */
+
+#ifdef __VXWORKS7__
+
+static __thread struct tls_data *__gthread_tls_data;
+
+#define VX_GET_TLS_DATA() __gthread_tls_data
+#define VX_SET_TLS_DATA(x) __gthread_tls_data = (x)
+
+#define VX_ENTER_TLS_DTOR()
+#define VX_LEAVE_TLS_DTOR()
+
+#else
+
extern void *__gthread_get_tls_data (void);
extern void __gthread_set_tls_data (void *data);
extern void __gthread_enter_tls_dtor_context (void);
extern void __gthread_leave_tls_dtor_context (void);
-#ifndef __RTP__
+#define VX_GET_TLS_DATA() __gthread_get_tls_data()
+#define VX_SET_TLS_DATA(x) __gthread_set_tls_data(x)
-extern void *__gthread_get_tsd_data (WIND_TCB *tcb);
-extern void __gthread_set_tsd_data (WIND_TCB *tcb, void *data);
-extern void __gthread_enter_tsd_dtor_context (WIND_TCB *tcb);
-extern void __gthread_leave_tsd_dtor_context (WIND_TCB *tcb);
+#define VX_ENTER_TLS_DTOR() __gthread_enter_tls_dtor_context ()
+#define VX_LEAVE_TLS_DTOR() __gthread_leave_tls_dtor_context ()
-#endif /* __RTP__ */
+#endif /* __VXWORKS7__ */
/* This is a global structure which records all of the active keys.
key is valid. */
static struct tls_keys tls_keys =
{
- { 0, 0, 0, 0 },
+ { NULL, NULL, NULL, NULL },
{ 1, 1, 1, 1 }
};
count protects us from calling a stale destructor. It does
need to read tls_keys.dtor[key] atomically. */
-static void
+void
tls_delete_hook (void *tcb ATTRIBUTE_UNUSED)
{
struct tls_data *data;
__gthread_key_t key;
-#ifdef __RTP__
- data = __gthread_get_tls_data ();
-#else
- /* In kernel mode, we can be called in the context of the thread
- doing the killing, so must use the TCB to determine the data of
- the thread being killed. */
- data = __gthread_get_tsd_data (tcb);
-#endif
-
+ data = VX_GET_TLS_DATA();
+
if (data && data->owner == &self_owner)
{
-#ifdef __RTP__
- __gthread_enter_tls_dtor_context ();
-#else
- __gthread_enter_tsd_dtor_context (tcb);
-#endif
+ VX_ENTER_TLS_DTOR();
for (key = 0; key < MAX_KEYS; key++)
{
if (data->generation[key] == tls_keys.generation[key])
}
}
free (data);
-#ifdef __RTP__
- __gthread_leave_tls_dtor_context ();
-#else
- __gthread_leave_tsd_dtor_context (tcb);
-#endif
-#ifdef __RTP__
- __gthread_set_tls_data (0);
-#else
- __gthread_set_tsd_data (tcb, 0);
-#endif
+ VX_LEAVE_TLS_DTOR();
+ VX_SET_TLS_DATA(NULL);
}
-}
+}
/* Initialize global data used by the TLS system. */
static void
if (key >= MAX_KEYS)
return 0;
- data = __gthread_get_tls_data ();
+ data = GET_VX_TLS_DATA();
if (!data)
return 0;
if (key >= MAX_KEYS)
return EINVAL;
- data = __gthread_get_tls_data ();
+ data = VX_GET_TLS_DATA();
+
if (!data)
{
if (!delete_hook_installed)
memset (data, 0, sizeof (struct tls_data));
data->owner = &self_owner;
- __gthread_set_tls_data (data);
+
+ VX_SET_TLS_DATA(data);
}
generation = tls_keys.generation[key];
--- /dev/null
+/* Copyright (C) 2002-2019 Free Software Foundation, Inc.
+ Contributed by Zack Weinberg <zack@codesourcery.com>
+
+This file is part of GCC.
+
+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 3, or (at your option) any later
+version.
+
+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.
+
+Under Section 7 of GPL version 3, you are granted additional
+permissions described in the GCC Runtime Library Exception, version
+3.1, as published by the Free Software Foundation.
+
+You should have received a copy of the GNU General Public License and
+a copy of the GCC Runtime Library Exception along with this program;
+see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
+<http://www.gnu.org/licenses/>. */
+
+/* Threads compatibility routines for libgcc2 for VxWorks.
+
+ This file implements the init-once service exposed by gthr-vxworks.h. */
+
+#include "tconfig.h"
+#include "tsystem.h"
+#include "gthr.h"
+
+#if defined(__GTHREADS)
+
+#include <vxWorks.h>
+
+#ifndef __RTP__
+# include <vxLib.h>
+# include <taskHookLib.h>
+#else /* __RTP__ */
+# include <errno.h>
+#endif /* __RTP__ */
+
+/* ----------------------------- Init-once ------------------------------- */
+
+static void
+__release (__gthread_once_t ** __guard)
+{
+ (*__guard)->busy = 0;
+}
+
+int
+__gthread_once (__gthread_once_t * __guard, void (*__func) (void))
+{
+ if (__guard->done)
+ return 0;
+
+ /* Busy-wait until we have exclusive access to the state. Check if
+ another thread managed to perform the init call in the interim. */
+
+ while (!__TAS(&__guard->busy))
+ {
+ if (__guard->done)
+ return 0;
+ taskDelay (1);
+ }
+
+ if (!__guard->done)
+ {
+#ifndef __USING_SJLJ_EXCEPTIONS__
+ /* Setup a cleanup to release the guard when __func() throws an
+ exception. We cannot use this with SJLJ exceptions as
+ Unwind_Register calls __gthread_once, leading to an infinite
+ recursion. */
+ __attribute__ ((cleanup (__release)))
+ __gthread_once_t *__temp = __guard;
+#endif
+
+ __func ();
+ __guard->done = 1;
+ }
+
+ __release(&__guard);
+ return 0;
+}
+
+#endif /* __GTHREADS */
/* Threads compatibility routines for libgcc2 and libobjc for VxWorks. */
/* Compile this one with gcc. */
-/* Copyright (C) 1997-2019 Free Software Foundation, Inc.
+/* Copyright (C) 1997-2018 Free Software Foundation, Inc.
Contributed by Mike Stump <mrs@wrs.com>.
This file is part of GCC.
#include "gthr-posix.h"
#else
-#ifdef __cplusplus
-#define UNUSED(x)
-#else
-#define UNUSED(x) x __attribute__((__unused__))
+
+#include <vxWorks.h>
+#include <version.h>
+
+/* Conditional compilation directives are easier to read when they fit on a
+ single line, which is helped by macros with shorter names. */
+#define _VXW_MAJOR _WRS_VXWORKS_MAJOR
+#define _VXW_MINOR _WRS_VXWORKS_MINOR
+#define _VXW_PRE_69 (_VXW_MAJOR < 6 || (_VXW_MAJOR == 6 && _VXW_MINOR < 9))
+
+/* Some VxWorks headers profusely use typedefs of a pointer to a function with
+ undefined number of arguments. */
+#pragma GCC diagnostic push
+ #pragma GCC diagnostic ignored "-Wstrict-prototypes"
+ #include <semLib.h>
+#pragma GCC diagnostic pop
+
+#include <errnoLib.h>
+
+
+/* --------------------- Test & Set/Swap internal API --------------------- */
+
+/* We use a bare atomic primitive with busy loops to handle mutual exclusion.
+ Inefficient, but reliable. The actual primitive used depends on the mode
+ (RTP vs Kernel) and the version of VxWorks. We define a macro and a type
+ here, for reuse without conditionals cluttering in the code afterwards. */
+
+/* RTP, pre 6.9. */
+
+#if defined(__RTP__) && _VXW_PRE_69
+
+#define __TAS(x) vxCas ((x), 0, 1)
+typedef volatile unsigned char __vx_tas_t;
+
+#endif
+
+/* RTP, 6.9 and beyond. */
+
+#if defined(__RTP__) && !_VXW_PRE_69
+
+#define __TAS(x) vxAtomicCas ((x), 0, 1)
+typedef atomic_t __vx_tas_t;
+
+#include <vxAtomicLib.h>
+
+#endif
+
+/* Kernel */
+
+#if !defined(__RTP__)
+
+#define __TAS(x) vxTas (x)
+typedef volatile unsigned char __vx_tas_t;
+
#endif
#ifdef __cplusplus
extern "C" {
#endif
+/* ------------------------ Base __GTHREADS support ----------------------- */
+
#define __GTHREADS 1
#define __gthread_active_p() 1
/* Mutexes are easy, except that they need to be initialized at runtime. */
-#include <semLib.h>
-
-typedef SEM_ID __gthread_mutex_t;
/* All VxWorks mutexes are recursive. */
+typedef SEM_ID __gthread_mutex_t;
typedef SEM_ID __gthread_recursive_mutex_t;
-#define __GTHREAD_MUTEX_INIT_FUNCTION __gthread_mutex_init_function
-#define __GTHREAD_RECURSIVE_MUTEX_INIT_FUNCTION __gthread_recursive_mutex_init_function
+#define __GTHREAD_MUTEX_INIT_FUNCTION __gthread_mutex_init
+#define __GTHREAD_RECURSIVE_MUTEX_INIT_FUNCTION __gthread_recursive_mutex_init
+
+#define __CHECK_RESULT(result) (((result) == OK) ? OK : errnoGet())
+
+/* If a call to the VxWorks API fails, we must propagate the errno value. */
+#define __RETURN_ERRNO_IF_NOT_OK(exp) if ((exp) != OK) return errnoGet()
+
+/* Non re-entrant mutex implementation. Libstdc++ expects the default
+ gthread mutex to be non reentrant. */
static inline void
-__gthread_mutex_init_function (__gthread_mutex_t *mutex)
+__gthread_mutex_init (__gthread_mutex_t * __mutex)
{
- *mutex = semMCreate (SEM_Q_PRIORITY | SEM_INVERSION_SAFE | SEM_DELETE_SAFE);
+ if (!__mutex)
+ return;
+ *__mutex = semBCreate (SEM_Q_PRIORITY, SEM_FULL);
}
static inline int
-__gthread_mutex_destroy (__gthread_mutex_t *mutex)
+__gthread_mutex_destroy (__gthread_mutex_t * __mutex)
{
- semDelete(*mutex);
- return 0;
+ if (!__mutex)
+ return ERROR;
+ return __CHECK_RESULT (semDelete (*__mutex));
}
static inline int
-__gthread_mutex_lock (__gthread_mutex_t *mutex)
+__gthread_mutex_lock (__gthread_mutex_t * __mutex)
{
- return semTake (*mutex, WAIT_FOREVER);
+ if (!__mutex)
+ return ERROR;
+ return __CHECK_RESULT (semTake(*__mutex, WAIT_FOREVER));
}
static inline int
-__gthread_mutex_trylock (__gthread_mutex_t *mutex)
+__gthread_mutex_trylock (__gthread_mutex_t * __mutex)
{
- return semTake (*mutex, NO_WAIT);
+ if (!__mutex)
+ return ERROR;
+ return __CHECK_RESULT (semTake (*__mutex, NO_WAIT));
}
static inline int
-__gthread_mutex_unlock (__gthread_mutex_t *mutex)
+__gthread_mutex_unlock (__gthread_mutex_t * __mutex)
{
- return semGive (*mutex);
+ if (!__mutex)
+ return ERROR;
+ return __CHECK_RESULT (semGive (*__mutex));
}
+/* Recursive mutex implementation. The only change is that we use semMCreate()
+ instead of semBCreate(). */
+
static inline void
-__gthread_recursive_mutex_init_function (__gthread_recursive_mutex_t *mutex)
+__gthread_recursive_mutex_init (__gthread_recursive_mutex_t * __mutex)
{
- __gthread_mutex_init_function (mutex);
+ if (!__mutex)
+ return;
+ *__mutex =
+ semMCreate (SEM_Q_PRIORITY | SEM_INVERSION_SAFE | SEM_DELETE_SAFE);
}
static inline int
-__gthread_recursive_mutex_lock (__gthread_recursive_mutex_t *mutex)
+__gthread_recursive_mutex_destroy (__gthread_recursive_mutex_t * __mutex)
{
- return __gthread_mutex_lock (mutex);
+ return __gthread_mutex_destroy (__mutex);
}
static inline int
-__gthread_recursive_mutex_trylock (__gthread_recursive_mutex_t *mutex)
+__gthread_recursive_mutex_lock (__gthread_recursive_mutex_t * __mutex)
{
- return __gthread_mutex_trylock (mutex);
+ return __gthread_mutex_lock (__mutex);
}
static inline int
-__gthread_recursive_mutex_unlock (__gthread_recursive_mutex_t *mutex)
+__gthread_recursive_mutex_trylock (__gthread_recursive_mutex_t * __mutex)
{
- return __gthread_mutex_unlock (mutex);
+ return __gthread_mutex_trylock (__mutex);
}
static inline int
-__gthread_recursive_mutex_destroy (__gthread_recursive_mutex_t *__mutex)
+__gthread_recursive_mutex_unlock (__gthread_recursive_mutex_t * __mutex)
{
- return __gthread_mutex_destroy (__mutex);
+ return __gthread_mutex_unlock (__mutex);
}
-/* pthread_once is complicated enough that it's implemented
- out-of-line. See config/vxlib.c. */
-
typedef struct
{
-#if !defined(__RTP__)
+ /* PPC's test-and-set kernel mode implementation requires a pointer aligned
+ object, of which it only sets the first byte. We use padding in addition
+ to an alignment request here to maxmise the factors leading to the
+ desired actual alignment choice by the compiler. */
#if defined(__PPC__)
- __attribute ((aligned (__alignof (unsigned))))
-#endif
- volatile unsigned char busy;
+ __attribute ((aligned (__alignof__ (void *))))
#endif
+
+ __vx_tas_t busy;
volatile unsigned char done;
+
#if !defined(__RTP__) && defined(__PPC__)
- /* PPC's test-and-set implementation requires a 4 byte aligned
- object, of which it only sets the first byte. We use padding
- here, in order to maintain some amount of backwards
- compatibility. Without this padding, gthread_once objects worked
- by accident because they happen to be static objects and the ppc
- port automatically increased their alignment to 4 bytes. */
unsigned char pad1;
unsigned char pad2;
#endif
-}
-__gthread_once_t;
-
-#if defined (__RTP__)
-# define __GTHREAD_ONCE_INIT { 0 }
-#elif defined (__PPC__)
-# define __GTHREAD_ONCE_INIT { 0, 0, 0, 0 }
-#else
-# define __GTHREAD_ONCE_INIT { 0, 0 }
+#if !defined(__RTP__) && defined(__PPC64__)
+ unsigned char pad3;
+ unsigned char pad4;
+ unsigned char pad5;
+ unsigned char pad6;
#endif
+} __gthread_once_t;
+
+#define __GTHREAD_ONCE_INIT { 0 }
extern int __gthread_once (__gthread_once_t *__once, void (*__func)(void));
-/* Thread-specific data requires a great deal of effort, since VxWorks
- is not really set up for it. See config/vxlib.c for the gory
- details. All the TSD routines are sufficiently complex that they
+/* All the TSD routines are sufficiently complex that they
need to be implemented out of line. */
typedef unsigned int __gthread_key_t;
-extern int __gthread_key_create (__gthread_key_t *__keyp, void (*__dtor)(void *));
+extern int __gthread_key_create (__gthread_key_t *__keyp,
+ void (*__dtor)(void *));
extern int __gthread_key_delete (__gthread_key_t __key);
extern void *__gthread_getspecific (__gthread_key_t __key);
extern int __gthread_setspecific (__gthread_key_t __key, void *__ptr);
-#undef UNUSED
+/* ------------------ Base condition variables support ------------------- */
+
+#define __GTHREAD_HAS_COND 1
+
+typedef SEM_ID __gthread_cond_t;
+
+#define __GTHREAD_COND_INIT_FUNCTION __gthread_cond_init
+
+/* Condition variable declarations. */
+
+extern void __gthread_cond_init (__gthread_cond_t *cond);
+
+extern int __gthread_cond_destroy (__gthread_cond_t *cond);
+
+extern int __gthread_cond_broadcast (__gthread_cond_t *cond);
+
+extern int __gthread_cond_wait (__gthread_cond_t *cond,
+ __gthread_mutex_t *mutex);
+
+extern int __gthread_cond_wait_recursive (__gthread_cond_t *cond,
+ __gthread_recursive_mutex_t *mutex);
+
+/* ----------------------- C++0x thread support ------------------------- */
+
+/* We do not support C++0x threads on that VxWorks 653, which we can
+ recognize by VTHREADS being defined. */
+
+#ifndef VTHREADS
+
+#define __GTHREADS_CXX0X 1
+
+#include <limits.h>
+#include <time.h>
+#include <tickLib.h>
+#include <sysLib.h>
+#include <version.h>
+
+typedef struct
+{
+ TASK_ID task_id;
+ void *return_value;
+
+ /* This mutex is used to block in join() while the return value is
+ unavailable. */
+ __gthread_mutex_t return_value_available;
+
+ /* Before freeing the structure in the task wrapper, we need to wait until
+ join() or detach() are called on that thread. */
+ __gthread_mutex_t delete_ok;
+} __gthread_tcb;
+
+typedef __gthread_tcb *__gthread_t;
+
+/* Typedefs specific to different vxworks versions. */
+#if _VXW_PRE_69
+ typedef int _Vx_usr_arg_t;
+ #define TASK_ID_NULL ((TASK_ID)NULL)
+ #define SEM_ID_NULL ((SEM_ID)NULL)
+#endif
+
+typedef struct timespec __gthread_time_t;
+
+/* Timed mutex lock declarations. */
+
+extern int __gthread_mutex_timedlock (__gthread_mutex_t *m,
+ const __gthread_time_t *abs_time);
+
+extern int __gthread_recursive_mutex_timedlock
+ (__gthread_recursive_mutex_t *mutex,
+ const __gthread_time_t *abs_timeout);
+
+/* Timed condition variable declarations. */
+
+extern int __gthread_cond_signal (__gthread_cond_t *cond);
+extern int __gthread_cond_timedwait (__gthread_cond_t *cond,
+ __gthread_mutex_t *mutex,
+ const __gthread_time_t *abs_timeout);
+
+/* gthreads declarations. */
+
+extern int __gthread_equal (__gthread_t t1, __gthread_t t2);
+extern int __gthread_yield (void);
+extern int __gthread_create (__gthread_t *__threadid,
+ void *(*__func) (void*),
+ void *__args);
+extern int __gthread_join (__gthread_t thread, void **value_ptr);
+extern int __gthread_detach (__gthread_t thread);
+
+extern __gthread_t __gthread_self (void);
+
+#endif
#ifdef __cplusplus
}
--- /dev/null
+# Extra libgcc2 modules used by gthr-vxworks.h functions
+LIB2ADDEH += $(srcdir)/config/gthr-vxworks.c\
+ $(srcdir)/config/gthr-vxworks-cond.c\
+ $(srcdir)/config/gthr-vxworks-thread.c\
+ $(srcdir)/config/gthr-vxworks-tls.c
\ No newline at end of file
LIB2FUNCS_EXCLUDE += _clear_cache
LIB2ADD += $(srcdir)/config/vxcache.c
-# Extra libgcc2 modules used by gthr-vxworks.h functions
-LIB2ADDEH += $(srcdir)/config/vxlib.c $(srcdir)/config/vxlib-tls.c
-
# This ensures that the correct target headers are used; some VxWorks
# system headers have names that collide with GCC's internal (host)
# headers, e.g. regs.h. Make sure the local libgcc headers still
LIB2FUNCS_EXCLUDE += _clear_cache
LIB2ADD += $(srcdir)/config/vxcache.c
-# Extra libgcc2 modules used by gthr-vxworks.h functions
-LIB2ADDEH += $(srcdir)/config/vxlib.c $(srcdir)/config/vxlib-tls.c
-
# This ensures that the correct target headers are used; some VxWorks
# system headers have names that collide with GCC's internal (host)
# headers, e.g. regs.h. Make sure the local libgcc headers still
*/mrtp*) echo -I$(VSB_DIR)/usr/h/public -I$(VSB_DIR)/usr/h ;; \
*) echo -I$(VSB_DIR)/krnl/h/system -I$(VSB_DIR)/krnl/h/public ;; \
esac`
-
+++ /dev/null
-/* Copyright (C) 2002-2019 Free Software Foundation, Inc.
- Contributed by Zack Weinberg <zack@codesourcery.com>
-
-This file is part of GCC.
-
-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 3, or (at your option) any later
-version.
-
-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.
-
-Under Section 7 of GPL version 3, you are granted additional
-permissions described in the GCC Runtime Library Exception, version
-3.1, as published by the Free Software Foundation.
-
-You should have received a copy of the GNU General Public License and
-a copy of the GCC Runtime Library Exception along with this program;
-see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
-<http://www.gnu.org/licenses/>. */
-
-/* Threads compatibility routines for libgcc2 for VxWorks.
- These are out-of-line routines called from gthr-vxworks.h. */
-
-#include "tconfig.h"
-#include "tsystem.h"
-#include "gthr.h"
-
-#if defined(__GTHREADS)
-#include <vxWorks.h>
-#ifndef __RTP__
-#include <vxLib.h>
-#endif
-#include <taskLib.h>
-#ifndef __RTP__
-#include <taskHookLib.h>
-#else
-# include <errno.h>
-#endif
-
-/* Init-once operation.
-
- This would be a clone of the implementation from gthr-solaris.h,
- except that we have a bootstrap problem - the whole point of this
- exercise is to prevent double initialization, but if two threads
- are racing with each other, once->mutex is liable to be initialized
- by both. Then each thread will lock its own mutex, and proceed to
- call the initialization routine.
-
- So instead we use a bare atomic primitive (vxTas()) to handle
- mutual exclusion. Threads losing the race then busy-wait, calling
- taskDelay() to yield the processor, until the initialization is
- completed. Inefficient, but reliable. */
-
-int
-__gthread_once (__gthread_once_t *guard, void (*func)(void))
-{
- if (guard->done)
- return 0;
-
-#ifdef __RTP__
- __gthread_lock_library ();
-#else
- while (!vxTas ((void *)&guard->busy))
- {
-#ifdef __PPC__
- /* This can happen on powerpc, which is using all 32 bits
- of the gthread_once_t structure. */
- if (guard->done)
- return 0;
-#endif
- taskDelay (1);
- }
-#endif
-
- /* Only one thread at a time gets here. Check ->done again, then
- go ahead and call func() if no one has done it yet. */
- if (!guard->done)
- {
- func ();
- guard->done = 1;
- }
-
-#ifdef __RTP__
- __gthread_unlock_library ();
-#else
- guard->busy = 0;
-#endif
- return 0;
-}
-
-#endif /* __GTHREADS */
projects / thirdparty / gcc.git / commitdiff
