Subversion Repositories Kolibri OS

Compare Revisions

Ignore whitespace Rev 6519 → Rev 6520

/contrib/toolchain/gcc/5x/libgcc/Makefile
64,10 → 64,10
_tf_to_df _tf_to_sf _thenan_tf _tf_to_usi _usi_to_tf
 
# Additional sources to handle exceptions; overridden by targets as needed.
LIB2ADDEH = unwind-dw2.c unwind-dw2-fde.c unwind-sjlj.c unwind-c.c
#LIB2ADDEH = unwind-dw2.c unwind-dw2-fde.c unwind-sjlj.c unwind-c.c
LIB2ADDEHSTATIC = $(LIB2ADDEH)
 
#LIB2ADD = $(srcdir)/config/i386/gthr-win32.c
LIB2ADD = config/i386/gthr-kos32.c
EH_MODEL = dw2
CUSTOM_CRTSTUFF = yes
 
451,7 → 451,7
 
c_flags := -fexceptions
 
#libgcc-objects += $(addsuffix $(objext),$(basename $(notdir $(LIB2ADDEH))))
libgcc-objects += $(addsuffix $(objext),$(basename $(notdir $(LIB2ADDEH))))
 
iter-items := $(LIB2ADDEH)
include $(iterator)
/contrib/toolchain/gcc/5x/libgcc/config/i386/gthr-win32.c
File deleted
/contrib/toolchain/gcc/5x/libgcc/config/i386/gthr-win32.h
File deleted
/contrib/toolchain/gcc/5x/libgcc/config/i386/gthr-kos32.c
0,0 → 1,251
/* Implementation of Kos32-specific threads compatibility routines for
libgcc2.
 
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/>. */
 
#include "gthr-kos32.h"
 
#define FUTEX_INIT 0
#define FUTEX_DESTROY 1
#define FUTEX_WAIT 2
#define FUTEX_WAKE 3
 
unsigned int tls_alloc(void);
int tls_free(unsigned int key);
void *tls_get(unsigned int key);
void *tls_set(unsigned int key, void *val);
 
#define exchange_acquire(ptr, new) \
__atomic_exchange_4((ptr), (new), __ATOMIC_ACQUIRE)
 
#define exchange_release(ptr, new) \
__atomic_exchange_4((ptr), (new), __ATOMIC_RELEASE)
 
 
static inline void yield(void)
{
__asm__ __volatile__(
"int $0x40"
::"a"(68), "b"(1));
};
 
 
 
int __gthr_kos32_once (__gthread_once_t *once, void (*func) (void))
{
if (once == NULL || func == NULL)
return EINVAL;
 
if (! once->done)
{
if (__sync_add_and_fetch(&(once->started), 1) == 0)
{
(*func) ();
once->done = 1;
}
else
{
while (! once->done)
yield();
}
}
return 0;
};
 
int __gthr_kos32_key_create (__gthread_key_t *key,
void (*dtor) (void *) __attribute__((unused)))
{
int status = 0;
unsigned int tls_index = tls_alloc();
if (tls_index != 0xFFFFFFFF)
{
*key = tls_index;
#ifdef MINGW32_SUPPORTS_MT_EH
/* Mingw runtime will run the dtors in reverse order for each thread
when the thread exits. */
status = __mingwthr_key_dtor (*key, dtor);
#endif
}
else
status = -1;
return status;
}
 
int __gthr_kos32_key_delete (__gthread_key_t key)
{
return tls_free(key);
}
 
void* __gthr_kos32_getspecific (__gthread_key_t key)
{
void *ptr;
ptr = tls_get(key);
return ptr;
}
 
int __gthr_kos32_setspecific (__gthread_key_t key, const void *ptr)
{
tls_set(key, CONST_CAST2(void *, const void *, ptr));
return 0;
}
 
void __gthr_kos32_mutex_init_function (__gthread_mutex_t *mutex)
{
int handle;
 
mutex->lock = 0;
 
__asm__ volatile(
"int $0x40\t"
:"=a"(handle)
:"a"(77),"b"(FUTEX_INIT),"c"(mutex));
mutex->handle = handle;
}
 
void __gthr_kos32_mutex_destroy (__gthread_mutex_t *mutex)
{
int retval;
 
__asm__ volatile(
"int $0x40\t"
:"=a"(retval)
:"a"(77),"b"(FUTEX_DESTROY),"c"(mutex->handle));
}
 
int __gthr_kos32_mutex_lock (__gthread_mutex_t *mutex)
{
int tmp;
 
if( __sync_fetch_and_add(&mutex->lock, 1) == 0)
return 0;
 
while (exchange_acquire (&mutex->lock, 2) != 0)
{
__asm__ volatile(
"int $0x40\t\n"
:"=a"(tmp)
:"a"(77),"b"(FUTEX_WAIT),
"c"(mutex->handle),"d"(2),"S"(0));
}
return 0;
}
 
int __gthr_kos32_mutex_trylock (__gthread_mutex_t *mutex)
{
int zero = 0;
 
return __atomic_compare_exchange_4(&mutex->lock, &zero, 1,0,__ATOMIC_ACQUIRE,__ATOMIC_RELAXED);
}
 
int __gthr_kos32_mutex_unlock (__gthread_mutex_t *mutex)
{
int prev;
 
prev = exchange_release (&mutex->lock, 0);
 
if (prev != 1)
{
__asm__ volatile(
"int $0x40\t"
:"=a"(prev)
:"a"(77),"b"(FUTEX_WAKE),
"c"(mutex->handle),"d"(1));
};
return 0;
}
 
void __gthr_kos32_recursive_mutex_init_function (__gthread_recursive_mutex_t *mutex)
{
// mutex->counter = -1;
mutex->depth = 0;
mutex->owner = 0;
// mutex->sema = CreateSemaphoreW (NULL, 0, 65535, NULL);
}
 
#if 0
int
__gthr_win32_recursive_mutex_lock (__gthread_recursive_mutex_t *mutex)
{
DWORD me = GetCurrentThreadId();
if (InterlockedIncrement (&mutex->counter) == 0)
{
mutex->depth = 1;
mutex->owner = me;
}
else if (mutex->owner == me)
{
InterlockedDecrement (&mutex->counter);
++(mutex->depth);
}
else if (WaitForSingleObject (mutex->sema, INFINITE) == WAIT_OBJECT_0)
{
mutex->depth = 1;
mutex->owner = me;
}
else
{
/* WaitForSingleObject returns WAIT_FAILED, and we can only do
some best-effort cleanup here. */
InterlockedDecrement (&mutex->counter);
return 1;
}
return 0;
}
 
int
__gthr_win32_recursive_mutex_trylock (__gthread_recursive_mutex_t *mutex)
{
DWORD me = GetCurrentThreadId();
if (__GTHR_W32_InterlockedCompareExchange (&mutex->counter, 0, -1) < 0)
{
mutex->depth = 1;
mutex->owner = me;
}
else if (mutex->owner == me)
++(mutex->depth);
else
return 1;
 
return 0;
}
 
int
__gthr_win32_recursive_mutex_unlock (__gthread_recursive_mutex_t *mutex)
{
--(mutex->depth);
if (mutex->depth == 0)
{
mutex->owner = 0;
 
if (InterlockedDecrement (&mutex->counter) >= 0)
return ReleaseSemaphore (mutex->sema, 1, NULL) ? 0 : 1;
}
 
return 0;
}
 
int
__gthr_win32_recursive_mutex_destroy (__gthread_recursive_mutex_t *mutex)
{
CloseHandle ((HANDLE) mutex->sema);
return 0;
}
 
#endif
/contrib/toolchain/gcc/5x/libgcc/config/i386/gthr-kos32.h
0,0 → 1,216
/* Threads compatibility routines for libgcc2 and libobjc. */
/* Compile this one with gcc. */
 
/* Copyright (C) 1999-2015 Free Software Foundation, Inc.
Contributed by Mumit Khan <khan@xraylith.wisc.edu>.
 
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/>. */
 
#ifndef GCC_GTHR_KOS32_H
#define GCC_GTHR_KOS32_H
 
/* Make sure CONST_CAST2 (origin in system.h) is declared. */
#ifndef CONST_CAST2
#define CONST_CAST2(TOTYPE,FROMTYPE,X) ((__extension__(union {FROMTYPE _q; TOTYPE _nq;})(X))._nq)
#endif
 
 
#define __GTHREADS 1
 
#include <errno.h>
#include <stddef.h>
 
#ifndef __UNUSED_PARAM
#define __UNUSED_PARAM(x) x
#endif
 
 
#ifdef __cplusplus
extern "C" {
#endif
 
typedef unsigned long __gthread_key_t;
 
typedef struct
{
int done;
long started;
} __gthread_once_t;
 
typedef struct
{
volatile int lock;
int handle;
} __gthread_mutex_t;
 
typedef struct
{
volatile int lock;
int handle;
long depth;
unsigned long owner;
} __gthread_recursive_mutex_t;
 
#define __GTHREAD_ONCE_INIT {0, -1}
#define __GTHREAD_MUTEX_INIT_FUNCTION __gthread_mutex_init_function
 
#define __GTHREAD_RECURSIVE_MUTEX_INIT_FUNCTION \
__gthread_recursive_mutex_init_function
 
 
#if defined (_WIN32) && !defined(__CYGWIN__)
#define MINGW32_SUPPORTS_MT_EH 1
/* Mingw runtime >= v0.3 provides a magic variable that is set to nonzero
if -mthreads option was specified, or 0 otherwise. This is to get around
the lack of weak symbols in PE-COFF. */
extern int _CRT_MT;
extern int __mingwthr_key_dtor (unsigned long, void (*) (void *));
#endif /* _WIN32 && !__CYGWIN__ */
 
 
static inline int __gthread_active_p (void)
{
#ifdef MINGW32_SUPPORTS_MT_EH
return _CRT_MT;
#else
return 1;
#endif
}
 
extern int __gthr_kos32_once (__gthread_once_t *, void (*) (void));
extern int __gthr_kos32_key_create (__gthread_key_t *, void (*) (void*));
extern int __gthr_kos32_key_delete (__gthread_key_t);
extern void * __gthr_kos32_getspecific (__gthread_key_t);
extern int __gthr_kos32_setspecific (__gthread_key_t, const void *);
extern void __gthr_kos32_mutex_init_function (__gthread_mutex_t *);
extern int __gthr_kos32_mutex_lock (__gthread_mutex_t *);
extern int __gthr_kos32_mutex_trylock (__gthread_mutex_t *);
extern int __gthr_kos32_mutex_unlock (__gthread_mutex_t *);
extern void __gthr_kos32_recursive_mutex_init_function (__gthread_recursive_mutex_t *);
extern int __gthr_kos32_recursive_mutex_lock (__gthread_recursive_mutex_t *);
extern int __gthr_kos32_recursive_mutex_trylock (__gthread_recursive_mutex_t *);
extern int __gthr_kos32_recursive_mutex_unlock (__gthread_recursive_mutex_t *);
extern void __gthr_kos32_mutex_destroy (__gthread_mutex_t *);
extern int __gthr_kos32_recursive_mutex_destroy (__gthread_recursive_mutex_t *);
 
static inline int __gthread_once (__gthread_once_t *__once, void (*__func) (void))
{
if (__gthread_active_p ())
return __gthr_kos32_once (__once, __func);
else
return -1;
}
 
static inline int __gthread_key_create (__gthread_key_t *__key, void (*__dtor) (void *))
{
return __gthr_kos32_key_create (__key, __dtor);
}
 
static inline int __gthread_key_delete (__gthread_key_t __key)
{
return __gthr_kos32_key_delete (__key);
}
 
static inline void* __gthread_getspecific (__gthread_key_t __key)
{
return __gthr_kos32_getspecific (__key);
}
 
static inline int __gthread_setspecific (__gthread_key_t __key, const void *__ptr)
{
return __gthr_kos32_setspecific (__key, __ptr);
}
 
static inline void __gthread_mutex_init_function (__gthread_mutex_t *__mutex)
{
__gthr_kos32_mutex_init_function(__mutex);
}
 
static inline void __gthread_mutex_destroy (__gthread_mutex_t *__mutex)
{
__gthr_kos32_mutex_destroy (__mutex);
}
 
static inline int __gthread_mutex_lock (__gthread_mutex_t *__mutex)
{
if (__gthread_active_p ())
return __gthr_kos32_mutex_lock (__mutex);
else
return 0;
}
 
static inline int __gthread_mutex_trylock (__gthread_mutex_t *__mutex)
{
if (__gthread_active_p ())
return __gthr_kos32_mutex_trylock (__mutex);
else
return 0;
}
 
static inline int __gthread_mutex_unlock (__gthread_mutex_t *__mutex)
{
if (__gthread_active_p ())
return __gthr_kos32_mutex_unlock (__mutex);
else
return 0;
}
 
static inline void __gthread_recursive_mutex_init_function (__gthread_recursive_mutex_t *__mutex)
{
__gthr_kos32_recursive_mutex_init_function (__mutex);
}
 
static inline int __gthread_recursive_mutex_lock (__gthread_recursive_mutex_t *__mutex)
{
if (__gthread_active_p ())
return __gthr_kos32_recursive_mutex_lock (__mutex);
else
return 0;
}
 
static inline int __gthread_recursive_mutex_trylock (__gthread_recursive_mutex_t *__mutex)
{
if (__gthread_active_p ())
return __gthr_kos32_recursive_mutex_trylock (__mutex);
else
return 0;
}
 
static inline int __gthread_recursive_mutex_unlock (__gthread_recursive_mutex_t *__mutex)
{
if (__gthread_active_p ())
return __gthr_kos32_recursive_mutex_unlock (__mutex);
else
return 0;
}
 
static inline int __gthread_recursive_mutex_destroy (__gthread_recursive_mutex_t *__mutex)
{
return __gthr_kos32_recursive_mutex_destroy (__mutex);
}
 
 
#ifdef __cplusplus
}
#endif
 
#endif /* ! GCC_GTHR_WIN32_H */
/contrib/toolchain/gcc/5x/libgcc/gthr-default.h
0,0 → 1,216
/* Threads compatibility routines for libgcc2 and libobjc. */
/* Compile this one with gcc. */
 
/* Copyright (C) 1999-2015 Free Software Foundation, Inc.
Contributed by Mumit Khan <khan@xraylith.wisc.edu>.
 
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/>. */
 
#ifndef GCC_GTHR_KOS32_H
#define GCC_GTHR_KOS32_H
 
/* Make sure CONST_CAST2 (origin in system.h) is declared. */
#ifndef CONST_CAST2
#define CONST_CAST2(TOTYPE,FROMTYPE,X) ((__extension__(union {FROMTYPE _q; TOTYPE _nq;})(X))._nq)
#endif
 
 
#define __GTHREADS 1
 
#include <errno.h>
#include <stddef.h>
 
#ifndef __UNUSED_PARAM
#define __UNUSED_PARAM(x) x
#endif
 
 
#ifdef __cplusplus
extern "C" {
#endif
 
typedef unsigned long __gthread_key_t;
 
typedef struct
{
int done;
long started;
} __gthread_once_t;
 
typedef struct
{
volatile int lock;
int handle;
} __gthread_mutex_t;
 
typedef struct
{
volatile int lock;
int handle;
long depth;
unsigned long owner;
} __gthread_recursive_mutex_t;
 
#define __GTHREAD_ONCE_INIT {0, -1}
#define __GTHREAD_MUTEX_INIT_FUNCTION __gthread_mutex_init_function
 
#define __GTHREAD_RECURSIVE_MUTEX_INIT_FUNCTION \
__gthread_recursive_mutex_init_function
 
 
#if defined (_WIN32) && !defined(__CYGWIN__)
#define MINGW32_SUPPORTS_MT_EH 1
/* Mingw runtime >= v0.3 provides a magic variable that is set to nonzero
if -mthreads option was specified, or 0 otherwise. This is to get around
the lack of weak symbols in PE-COFF. */
extern int _CRT_MT;
extern int __mingwthr_key_dtor (unsigned long, void (*) (void *));
#endif /* _WIN32 && !__CYGWIN__ */
 
 
static inline int __gthread_active_p (void)
{
#ifdef MINGW32_SUPPORTS_MT_EH
return _CRT_MT;
#else
return 1;
#endif
}
 
extern int __gthr_kos32_once (__gthread_once_t *, void (*) (void));
extern int __gthr_kos32_key_create (__gthread_key_t *, void (*) (void*));
extern int __gthr_kos32_key_delete (__gthread_key_t);
extern void * __gthr_kos32_getspecific (__gthread_key_t);
extern int __gthr_kos32_setspecific (__gthread_key_t, const void *);
extern void __gthr_kos32_mutex_init_function (__gthread_mutex_t *);
extern int __gthr_kos32_mutex_lock (__gthread_mutex_t *);
extern int __gthr_kos32_mutex_trylock (__gthread_mutex_t *);
extern int __gthr_kos32_mutex_unlock (__gthread_mutex_t *);
extern void __gthr_kos32_recursive_mutex_init_function (__gthread_recursive_mutex_t *);
extern int __gthr_kos32_recursive_mutex_lock (__gthread_recursive_mutex_t *);
extern int __gthr_kos32_recursive_mutex_trylock (__gthread_recursive_mutex_t *);
extern int __gthr_kos32_recursive_mutex_unlock (__gthread_recursive_mutex_t *);
extern void __gthr_kos32_mutex_destroy (__gthread_mutex_t *);
extern int __gthr_kos32_recursive_mutex_destroy (__gthread_recursive_mutex_t *);
 
static inline int __gthread_once (__gthread_once_t *__once, void (*__func) (void))
{
if (__gthread_active_p ())
return __gthr_kos32_once (__once, __func);
else
return -1;
}
 
static inline int __gthread_key_create (__gthread_key_t *__key, void (*__dtor) (void *))
{
return __gthr_kos32_key_create (__key, __dtor);
}
 
static inline int __gthread_key_delete (__gthread_key_t __key)
{
return __gthr_kos32_key_delete (__key);
}
 
static inline void* __gthread_getspecific (__gthread_key_t __key)
{
return __gthr_kos32_getspecific (__key);
}
 
static inline int __gthread_setspecific (__gthread_key_t __key, const void *__ptr)
{
return __gthr_kos32_setspecific (__key, __ptr);
}
 
static inline void __gthread_mutex_init_function (__gthread_mutex_t *__mutex)
{
__gthr_kos32_mutex_init_function(__mutex);
}
 
static inline void __gthread_mutex_destroy (__gthread_mutex_t *__mutex)
{
__gthr_kos32_mutex_destroy (__mutex);
}
 
static inline int __gthread_mutex_lock (__gthread_mutex_t *__mutex)
{
if (__gthread_active_p ())
return __gthr_kos32_mutex_lock (__mutex);
else
return 0;
}
 
static inline int __gthread_mutex_trylock (__gthread_mutex_t *__mutex)
{
if (__gthread_active_p ())
return __gthr_kos32_mutex_trylock (__mutex);
else
return 0;
}
 
static inline int __gthread_mutex_unlock (__gthread_mutex_t *__mutex)
{
if (__gthread_active_p ())
return __gthr_kos32_mutex_unlock (__mutex);
else
return 0;
}
 
static inline void __gthread_recursive_mutex_init_function (__gthread_recursive_mutex_t *__mutex)
{
__gthr_kos32_recursive_mutex_init_function (__mutex);
}
 
static inline int __gthread_recursive_mutex_lock (__gthread_recursive_mutex_t *__mutex)
{
if (__gthread_active_p ())
return __gthr_kos32_recursive_mutex_lock (__mutex);
else
return 0;
}
 
static inline int __gthread_recursive_mutex_trylock (__gthread_recursive_mutex_t *__mutex)
{
if (__gthread_active_p ())
return __gthr_kos32_recursive_mutex_trylock (__mutex);
else
return 0;
}
 
static inline int __gthread_recursive_mutex_unlock (__gthread_recursive_mutex_t *__mutex)
{
if (__gthread_active_p ())
return __gthr_kos32_recursive_mutex_unlock (__mutex);
else
return 0;
}
 
static inline int __gthread_recursive_mutex_destroy (__gthread_recursive_mutex_t *__mutex)
{
return __gthr_kos32_recursive_mutex_destroy (__mutex);
}
 
 
#ifdef __cplusplus
}
#endif
 
#endif /* ! GCC_GTHR_WIN32_H */