kvx: add support for kvx arch to uClibc-ng

This commit adds support for Kalray VLIW family (kvx)

Kalray kv3 core is embedded in Kalray Coolidge SoC. This core which is the
third of the KV family has the following features:

    32/64 bits execution mode
    6-issue VLIW architecture
    64 x 64bits general purpose registers
    SIMD instructions
    little-endian

In order to build a usable toolchain, build scripts are provided at the
following address: https://github.com/kalray/build-scripts.

Kalray uses FOSS which is available at https://github.com/kalray
This includes Linux kernel, uClibc-ng, gcc, binutils, etc.

Signed-off-by: Clément Léger <cleger@kalray.eu>
Signed-off-by: Guillaume Thouvenin <gthouvenin@kalray.eu>
Signed-off-by: Laurent Thevenoux <lthevenoux@kalray.eu>
Signed-off-by: Marc Poulhies <mpoulhies@kalray.eu>
Signed-off-by: Marius Gligor <mgligor@kalray.eu>
Signed-off-by: Yann Sionneau <ysionneau@kalray.eu>

1 files changed, 77 insertions, 0 deletions

diff --git a/libpthread/nptl/sysdeps/unix/sysv/linux/kvx/pthread_once.c b/libpthread/nptl/sysdeps/unix/sysv/linux/kvx/pthread_once.c
new file mode 100644
index 000000000..0d2749edf
--- /dev/null
+++ b/libpthread/nptl/sysdeps/unix/sysv/linux/kvx/pthread_once.c
@@ -0,0 +1,77 @@
+/*
+ * This file is subject to the terms and conditions of the LGPL V2.1
+ * License.  See the file "COPYING" in the main directory of this archive
+ * for more details.
+ *
+ * Copyright (C) 2019 Kalray Inc.
+ */
+
+#include "pthreadP.h"
+#include <lowlevellock.h>
+
+unsigned long int __fork_generation attribute_hidden;
+
+static void
+clear_once_control (void *arg)
+{
+	pthread_once_t *once_control = (pthread_once_t *) arg;
+
+	*once_control = 0;
+	lll_futex_wake (once_control, INT_MAX, LLL_PRIVATE);
+}
+
+
+int
+__pthread_once (once_control, init_routine)
+	pthread_once_t *once_control;
+	void (*init_routine) (void);
+{
+	while (1)
+	{
+		int oldval, val, newval;
+
+		val = *once_control;
+		do
+		{
+			/* Check if the initialized has already been done. */
+			if ((val & 2) != 0)
+				return 0;
+
+			oldval = val;
+			newval = (oldval & 3) | __fork_generation | 1;
+			val = atomic_compare_and_exchange_val_acq (once_control, newval, oldval);
+		} while (__builtin_expect (val != oldval, 0));
+
+		/* Check if another thread already runs the initializer. */
+		if ((oldval & 1) != 0)
+		{
+		/* Check whether the initializer execution was interrupted
+		 * by a fork. */
+			if (((oldval ^ newval) & -4) == 0)
+			{
+				/* Same generation, some other thread was faster. Wait. */
+				lll_futex_wait (once_control, newval, LLL_PRIVATE);
+				continue;
+			}
+		}
+		/* This thread is the first here.  Do the initialization.
+		 * Register a cleanup handler so that in case the thread gets
+		 * interrupted the initialization can be restarted. */
+		pthread_cleanup_push (clear_once_control, once_control);
+
+		init_routine ();
+
+		pthread_cleanup_pop (0);
+
+		/* Add one to *once_control. */
+		atomic_increment (once_control);
+
+		/* Wake up all other threads. */
+		lll_futex_wake (once_control, INT_MAX, LLL_PRIVATE);
+		break;
+	}
+
+	return 0;
+}
+weak_alias (__pthread_once, pthread_once)
+strong_alias (__pthread_once, __pthread_once_internal)