mirrors/gcc
1
0
Fork 0
mirror of https://gcc.gnu.org/git/gcc.git synced 2024-11-23 10:54:07 +08:00
Code Issues Actions Packages Projects Releases Wiki Activity

Improve the thread support for VxWorks

Browse Source 
2019-11-12  Corentin Gay  <gay@adacore.com>
	    Jerome Lambourg  <lambourg@adacore.com>
	    Olivier Hainque  <hainque@adacore.com>

	libgcc/

	* 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.

Co-Authored-By: Jerome Lambourg <lambourg@adacore.com>
Co-Authored-By: Olivier Hainque <hainque@adacore.com>

From-SVN: r278249
This commit is contained in:
Corentin Gay 2019-11-14 15:58:31 +00:00 committed by Olivier Hainque
parent 78e49fb1bc
commit 806dd0472f
11 changed files with 845 additions and 229 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

34
libgcc/ChangeLog
View File

@ -1,3 +1,37 @@
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>

12
libgcc/config.host
View File

@ -1513,3 +1513,15 @@ aarch64*-*-*)
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

83
libgcc/config/gthr-vxworks-cond.c Normal file
View File

@ -0,0 +1,83 @@
/* 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);
}

349
libgcc/config/gthr-vxworks-thread.c Normal file
View File

@ -0,0 +1,349 @@
/* 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, &current) == 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, &current) == 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;
}

110
libgcc/config/vxlib-tls.c → libgcc/config/gthr-vxworks-tls.c
View File

@ -1,4 +1,4 @@
/* 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.
@ -23,21 +23,17 @@ 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.
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>
@ -46,31 +42,31 @@ see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
#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
@ -95,21 +91,34 @@ static int self_owner;
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.
@ -138,7 +147,7 @@ struct tls_keys
key is valid. */
static struct tls_keys tls_keys =
{
{ 0, 0, 0, 0 },
{ NULL, NULL, NULL, NULL },
{ 1, 1, 1, 1 }
};
@ -157,28 +166,17 @@ static __gthread_once_t tls_init_guard = __GTHREAD_ONCE_INIT;
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])
@ -190,19 +188,11 @@ tls_delete_hook (void *tcb ATTRIBUTE_UNUSED)
}
}
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
@ -303,7 +293,7 @@ __gthread_getspecific (__gthread_key_t key)
if (key >= MAX_KEYS)
return 0;
data = __gthread_get_tls_data ();
data = GET_VX_TLS_DATA();
if (!data)
return 0;
@ -332,7 +322,8 @@ __gthread_setspecific (__gthread_key_t key, void *value)
if (key >= MAX_KEYS)
return EINVAL;
data = __gthread_get_tls_data ();
data = VX_GET_TLS_DATA();
if (!data)
{
if (!delete_hook_installed)
@ -354,7 +345,8 @@ __gthread_setspecific (__gthread_key_t key, void *value)
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];

87
libgcc/config/gthr-vxworks.c Normal file
View File

@ -0,0 +1,87 @@
/* 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 */

292
libgcc/config/gthr-vxworks.h
View File

@ -1,6 +1,6 @@
/* 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.
@ -33,139 +33,295 @@ see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
#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)
{
return __gthread_mutex_lock (mutex);
}
static inline int
__gthread_recursive_mutex_trylock (__gthread_recursive_mutex_t *mutex)
{
return __gthread_mutex_trylock (mutex);
}
static inline int
__gthread_recursive_mutex_unlock (__gthread_recursive_mutex_t *mutex)
{
return __gthread_mutex_unlock (mutex);
}
static inline int
__gthread_recursive_mutex_destroy (__gthread_recursive_mutex_t *__mutex)
__gthread_recursive_mutex_destroy (__gthread_recursive_mutex_t * __mutex)
{
return __gthread_mutex_destroy (__mutex);
}
/* pthread_once is complicated enough that it's implemented
out-of-line. See config/vxlib.c. */
static inline int
__gthread_recursive_mutex_lock (__gthread_recursive_mutex_t * __mutex)
{
return __gthread_mutex_lock (__mutex);
}
static inline int
__gthread_recursive_mutex_trylock (__gthread_recursive_mutex_t * __mutex)
{
return __gthread_mutex_trylock (__mutex);
}
static inline int
__gthread_recursive_mutex_unlock (__gthread_recursive_mutex_t * __mutex)
{
return __gthread_mutex_unlock (__mutex);
}
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
}

5
libgcc/config/t-gthr-vxworks Normal file
View File

@ -0,0 +1,5 @@
# 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

3
libgcc/config/t-vxworks
View File

@ -6,9 +6,6 @@ LIBGCC2_DEBUG_CFLAGS =
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

4
libgcc/config/t-vxworks7
View File

@ -6,9 +6,6 @@ LIBGCC2_DEBUG_CFLAGS =
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
@ -21,4 +18,3 @@ LIBGCC2_INCLUDES = -nostdinc -I. \
*/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`

95
libgcc/config/vxlib.c
View File

@ -1,95 +0,0 @@
/* 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 */