Synopsys ARC port, adding support for ARC EM and HS cores -- continued from PR #8. (#28)

Synopsys ARC port, adding support for ARC EM and HS cores.

portable/ThirdParty/GCC/ARC_EM_HS/freertos_tls.c

@@ -0,0 +1,205 @@
+/*
+ * FreeRTOS Kernel V10.2.1
+ * Copyright (C) 2019 Amazon.com, Inc. or its affiliates.  All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of
+ * this software and associated documentation files (the "Software"), to deal in
+ * the Software without restriction, including without limitation the rights to
+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+ * the Software, and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+ * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+ * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+ * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *
+ * http://www.FreeRTOS.org
+ * http://aws.amazon.com/freertos
+ *
+ * 1 tab == 4 spaces!
+ */
+
+#if defined(__MW__)
+
+#include <stdint.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "FreeRTOS.h"
+
+#include "queue.h"
+#include "semphr.h"
+#include "task.h"
+
+#include "arc/arc_exception.h"
+#include "embARC_toolchain.h"
+#include "embARC_debug.h"
+
+#ifdef ENABLE_FREERTOS_TLS_DEBUG
+#define TLS_DEBUG(fmt, ...)	EMBARC_PRINTF(fmt, ##__VA_ARGS__)
+#else
+#define TLS_DEBUG(fmt, ...)
+#endif
+
+/*
+ * Runtime routines to execute constructors and
+ * destructors for task local storage.
+ */
+extern void __mw_run_tls_dtor();
+extern void __mw_run_tls_ctor();
+
+/*
+ * Linker generated symbols to mark .tls section addresses
+ * first byte .. last byte
+ */
+extern char _ftls[], _etls[];
+#pragma weak _ftls
+#pragma weak _etls
+
+void executable_requires_tls_section(void)
+{
+#if _ARC
+	for (;;) {
+		_flag(1);
+		_nop();
+		_nop();
+		_nop();
+		_nop();
+		_nop();
+	}
+#endif
+}
+#pragma off_inline(executable_requires_tls_section);
+#pragma alias(executable_requires_tls_section, "executable_requires_.tls_section");
+
+static void* init_task_tls(void)
+{
+	uint32_t len = (uint32_t)(_etls - _ftls);
+	void *tls = NULL;
+
+#if FREERTOS_HEAP_SEL == 3
+	#warning "FreeRTOS TLS support is not compatible with heap 3 solution(FREERTOS_HEAP_SEL=3)!"
+	#warning "You can change FREERTOS_HEAP_SEL in freertos.mk to select other heap solution."
+#else
+	tls = pvPortMalloc(len);
+#endif
+	if (tls) {
+		TLS_DEBUG("Malloc task tls:%dbytes\r\n", len);
+		memcpy(tls, _ftls, len);
+		__mw_run_tls_ctor();	// Run constructors
+	}
+	return tls;
+}
+
+static void free_task_tls(void *pxTCB)
+{
+	TaskHandle_t task2free = (TaskHandle_t)pxTCB;
+
+	if (task2free != NULL) {
+		void *tls = pvTaskGetThreadLocalStoragePointer(task2free, 0);
+		if (tls) {
+			TLS_DEBUG("Free task tls\r\n");
+			__mw_run_tls_dtor();
+			vPortFree(tls);
+			vTaskSetThreadLocalStoragePointer(task2free, 0, NULL);
+		}
+	}
+}
+
+void task_end_hook(void *pxTCB)
+{
+	free_task_tls(pxTCB);
+}
+
+static void* get_isr_tls(void)
+{
+	// In an ISR
+	static int first = 1;
+	if (_Rarely(first)) {
+		first = 0;
+		__mw_run_tls_ctor();	// Run constructors
+	}
+	return (void *)_ftls;
+}
+#pragma off_inline(get_isr_tls)
+
+static void* get_task_tls(void)
+{
+	TaskHandle_t cur_task;
+
+	cur_task = xTaskGetCurrentTaskHandle();
+	if (cur_task == NULL) return get_isr_tls();
+	void *tls = pvTaskGetThreadLocalStoragePointer(cur_task, 0);
+	if (tls == NULL) {
+		tls = init_task_tls();
+		if (tls) {
+			vTaskSetThreadLocalStoragePointer(cur_task, 0, tls);
+		} else {
+			tls = get_isr_tls();
+		}
+	}
+	return tls;
+}
+#pragma off_inline(get_task_tls)
+
+#if _ARC /* for ARC XCALLs need to preserve flags */
+	extern void * _Preserve_flags _mwget_tls(void);
+#endif
+
+/*
+ * Back end gens calls to find local data for this task
+ */
+void* _mwget_tls(void)
+{
+	if (_ftls == (char *)0) {
+		executable_requires_tls_section();
+	}
+	if (exc_sense()) { /* In ISR */
+		return get_isr_tls();
+	} else { /* In Task */
+		return get_task_tls();
+	}
+}
+
+
+// simple interface of thread safe
+typedef xSemaphoreHandle _lock_t;
+#if configUSE_RECURSIVE_MUTEXES != 1
+#error "configUSE_RECURSIVE_MUTEXES in FreeRTOSConfig.h need to 1"
+#endif
+
+void _mwmutex_create(_lock_t *mutex_ptr)
+{
+	*mutex_ptr = xSemaphoreCreateRecursiveMutex();
+}
+
+void _mwmutex_delete(_lock_t *mutex_ptr)
+{
+	if ((*mutex_ptr) != NULL) {
+		vSemaphoreDelete(*mutex_ptr);
+	}
+}
+
+void _mwmutex_lock(_lock_t mutex)
+{
+	if ((mutex) != NULL) {
+		while (xSemaphoreTakeRecursive(mutex, portMAX_DELAY) != pdTRUE);
+	}
+}
+
+void _mwmutex_unlock(_lock_t mutex)
+{
+	if ((mutex) != NULL) {
+		xSemaphoreGiveRecursive(mutex);
+	}
+}
+
+#else
+
+#endif /* __MW__ */