re-org platform APIs, simplify porting process (#201)

Co-authored-by: Xu Jun <jun1.xu@intel.com>

core/shared/platform/README.md

@@ -0,0 +1,10 @@
+This folder contains the platform abstract layer for multiple platforms.  To support a new platform, you can simply create a new folder here and implement all the APIs defined in [`include`](./include) folder.
+
+
+
+Refer to [port_wamr.md](../../../doc/port_wamr.md) for how to port WAMR to a target platform.
+
+
+
+
+

core/shared/platform/alios/alios_platform.c

@@ -3,15 +3,25 @@
  * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
  */
 
-#include "bh_platform.h"
-#include "bh_common.h"
-#include <stdlib.h>
-#include <string.h>
+#include "platform_api_vmcore.h"
+#include "platform_api_extension.h"
+
+int
+os_thread_sys_init();
+
+void
+os_thread_sys_destroy();
 
 int
 bh_platform_init()
 {
-    return 0;
+    return os_thread_sys_init();
+}
+
+void
+bh_platform_destroy()
+{
+    os_thread_sys_destroy();
 }
 
 void *
@@ -32,24 +42,24 @@ os_free(void *ptr)
 }
 
 void *
-bh_mmap(void *hint, unsigned int size, int prot, int flags)
+os_mmap(void *hint, unsigned int size, int prot, int flags)
 {
     return BH_MALLOC(size);
 }
 
 void
-bh_munmap(void *addr, uint32 size)
+os_munmap(void *addr, uint32 size)
 {
     return BH_FREE(addr);
 }
 
 int
-bh_mprotect(void *addr, uint32 size, int prot)
+os_mprotect(void *addr, uint32 size, int prot)
 {
     return 0;
 }
 
 void
-bh_dcache_flush()
+os_dcache_flush()
 {
 }

core/shared/platform/alios/alios_thread.c

@@ -0,0 +1,341 @@
+/*
+ * Copyright (C) 2019 Intel Corporation.  All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+ */
+
+#include "platform_api_vmcore.h"
+#include "platform_api_extension.h"
+
+#define bh_assert(v) do {                                   \
+     if (!(v)) {                                            \
+       printf("\nASSERTION FAILED: %s, at %s, line %d\n",   \
+              #v, __FILE__, __LINE__);                      \
+       aos_reboot();                                        \
+       while (1);                                           \
+     }                                                      \
+  } while (0)
+
+struct os_thread_data;
+typedef struct os_thread_wait_node {
+    aos_sem_t sem;
+    os_thread_wait_list next;
+} os_thread_wait_node;
+
+typedef struct os_thread_data {
+    /* Thread body */
+    aos_task_t thread;
+    /* Thread start routine */
+    thread_start_routine_t start_routine;
+    /* Thread start routine argument */
+    void *arg;
+    /* Thread local root */
+    void *tlr;
+    /* Wait node of current thread */
+    os_thread_wait_node wait_node;
+    /* Lock for waiting list */
+    aos_mutex_t wait_list_lock;
+    /* Waiting list of other threads who are joining this thread */
+    os_thread_wait_list thread_wait_list;
+} os_thread_data;
+
+static bool is_thread_sys_inited = false;
+
+/* Thread data of supervisor thread */
+static os_thread_data supervisor_thread_data;
+
+/* Thread data key */
+static aos_task_key_t thread_data_key;
+
+/* Thread name index */
+static int thread_name_index;
+
+int
+os_thread_sys_init()
+{
+    if (is_thread_sys_inited)
+        return BHT_OK;
+
+    if (aos_task_key_create(&thread_data_key) != 0)
+        return BHT_ERROR;
+
+    /* Initialize supervisor thread data */
+    memset(&supervisor_thread_data, 0, sizeof(supervisor_thread_data));
+
+    if (aos_sem_new(&supervisor_thread_data.wait_node.sem, 1) != 0) {
+        aos_task_key_delete(thread_data_key);
+        return BHT_ERROR;
+    }
+
+    if (aos_task_setspecific(thread_data_key, &supervisor_thread_data)) {
+        aos_sem_free(&supervisor_thread_data.wait_node.sem);
+        aos_task_key_delete(thread_data_key);
+        return BHT_ERROR;
+    }
+
+    is_thread_sys_inited = true;
+    return BHT_OK;
+}
+
+void
+os_thread_sys_destroy()
+{
+    if (is_thread_sys_inited) {
+        aos_task_key_delete(thread_data_key);
+        aos_sem_free(&supervisor_thread_data.wait_node.sem);
+        is_thread_sys_inited = false;
+    }
+}
+
+static os_thread_data *
+thread_data_current()
+{
+    return aos_task_getspecific(thread_data_key);
+}
+
+static void
+os_thread_cleanup(void)
+{
+    os_thread_data *thread_data = thread_data_current();
+    os_thread_wait_list thread_wait_list;
+    aos_mutex_t *wait_list_lock;
+    aos_sem_t *wait_node_sem;
+
+    bh_assert(thread_data != NULL);
+    wait_list_lock = &thread_data->wait_list_lock;
+    thread_wait_list = thread_data->thread_wait_list;
+    wait_node_sem = &thread_data->wait_node.sem;
+
+    /* Free thread data firstly */
+    BH_FREE(thread_data);
+
+    aos_mutex_lock(wait_list_lock, AOS_WAIT_FOREVER);
+    if (thread_wait_list) {
+        /* Signal each joining thread */
+        os_thread_wait_list head = thread_wait_list;
+        while (head) {
+            os_thread_wait_list next = head->next;
+            aos_sem_signal(&head->sem);
+            head = next;
+        }
+    }
+    aos_mutex_unlock(wait_list_lock);
+
+    /* Free sem and lock */
+    aos_sem_free(wait_node_sem);
+    aos_mutex_free(wait_list_lock);
+}
+
+static void
+os_thread_wrapper(void *arg)
+{
+    os_thread_data *thread_data = arg;
+
+    /* Set thread custom data */
+    if (!aos_task_setspecific(thread_data_key, thread_data))
+        thread_data->start_routine(thread_data->arg);
+
+    os_thread_cleanup();
+}
+
+int
+os_thread_create(korp_tid *p_tid, thread_start_routine_t start,
+                 void *arg, unsigned int stack_size)
+{
+    return os_thread_create_with_prio(p_tid, start, arg, stack_size,
+                                      BH_THREAD_DEFAULT_PRIORITY);
+}
+
+int
+os_thread_create_with_prio(korp_tid *p_tid, thread_start_routine_t start,
+                           void *arg, unsigned int stack_size, int prio)
+{
+    os_thread_data *thread_data;
+    char thread_name[32];
+
+    if (!p_tid || !stack_size)
+        return BHT_ERROR;
+
+    /* Create and initialize thread data */
+    if (!(thread_data = BH_MALLOC(sizeof(os_thread_data))))
+        return BHT_ERROR;
+
+    memset(thread_data, 0, sizeof(os_thread_data));
+
+    thread_data->start_routine = start;
+    thread_data->arg = arg;
+
+    if (aos_sem_new(&thread_data->wait_node.sem, 1) != 0)
+        goto fail1;
+
+    if (aos_mutex_new(&thread_data->wait_list_lock))
+        goto fail2;
+
+    snprintf(thread_name, sizeof(thread_name), "%s%d",
+            "wasm-thread-", ++thread_name_index);
+
+    /* Create the thread */
+    if (aos_task_new_ext((aos_task_t*)thread_data, thread_name,
+                          os_thread_wrapper, thread_data,
+                          stack_size, prio))
+        goto fail3;
+
+    aos_msleep(10);
+    *p_tid = (korp_tid)thread_data;
+    return BHT_OK;
+
+fail3:
+    aos_mutex_free(&thread_data->wait_list_lock);
+fail2:
+    aos_sem_free(&thread_data->wait_node.sem);
+fail1:
+    BH_FREE(thread_data);
+    return BHT_ERROR;
+}
+
+korp_tid
+os_self_thread()
+{
+    return (korp_tid)aos_task_getspecific(thread_data_key);
+}
+
+int
+os_thread_join (korp_tid thread, void **value_ptr)
+{
+    (void)value_ptr;
+    os_thread_data *thread_data, *curr_thread_data;
+
+    /* Get thread data of current thread */
+    curr_thread_data = thread_data_current();
+    curr_thread_data->wait_node.next = NULL;
+
+    /* Get thread data */
+    thread_data = (os_thread_data*)thread;
+
+    aos_mutex_lock(&thread_data->wait_list_lock, AOS_WAIT_FOREVER);
+    if (!thread_data->thread_wait_list)
+        thread_data->thread_wait_list = &curr_thread_data->wait_node;
+    else {
+        /* Add to end of waiting list */
+        os_thread_wait_node *p = thread_data->thread_wait_list;
+        while (p->next)
+            p = p->next;
+        p->next = &curr_thread_data->wait_node;
+    }
+    aos_mutex_unlock(&thread_data->wait_list_lock);
+
+    /* Wait the sem */
+    aos_sem_wait(&curr_thread_data->wait_node.sem, AOS_WAIT_FOREVER);
+
+    return BHT_OK;
+}
+
+int
+os_mutex_init(korp_mutex *mutex)
+{
+    return aos_mutex_new(mutex) == 0 ? BHT_OK : BHT_ERROR;
+}
+
+int
+os_mutex_destroy(korp_mutex *mutex)
+{
+    aos_mutex_free(mutex);
+    return BHT_OK;
+}
+
+void
+os_mutex_lock(korp_mutex *mutex)
+{
+    aos_mutex_lock(mutex, AOS_WAIT_FOREVER);
+}
+
+void
+os_mutex_unlock(korp_mutex *mutex)
+{
+    aos_mutex_unlock(mutex);
+}
+
+int
+os_cond_init(korp_cond *cond)
+{
+    if (aos_mutex_new(&cond->wait_list_lock) != 0)
+        return BHT_ERROR;
+
+    cond->thread_wait_list = NULL;
+    return BHT_OK;
+}
+
+int
+os_cond_destroy(korp_cond *cond)
+{
+    aos_mutex_free(&cond->wait_list_lock);
+    return BHT_OK;
+}
+
+static int
+os_cond_wait_internal(korp_cond *cond, korp_mutex *mutex,
+                      bool timed, int mills)
+{
+    os_thread_wait_node *node = &thread_data_current()->wait_node;
+
+    node->next = NULL;
+
+    aos_mutex_lock(&cond->wait_list_lock, AOS_WAIT_FOREVER);
+    if (!cond->thread_wait_list)
+        cond->thread_wait_list = node;
+    else {
+        /* Add to end of wait list */
+        os_thread_wait_node *p = cond->thread_wait_list;
+        while (p->next)
+            p = p->next;
+        p->next = node;
+    }
+    aos_mutex_unlock(&cond->wait_list_lock);
+
+    /* Unlock mutex, wait sem and lock mutex again */
+    aos_mutex_unlock(mutex);
+    aos_sem_wait(&node->sem, timed ? mills : AOS_WAIT_FOREVER);
+    aos_mutex_lock(mutex, AOS_WAIT_FOREVER);
+
+    /* Remove wait node from wait list */
+    aos_mutex_lock(&cond->wait_list_lock, AOS_WAIT_FOREVER);
+    if (cond->thread_wait_list == node)
+        cond->thread_wait_list = node->next;
+    else {
+        /* Remove from the wait list */
+        os_thread_wait_node *p = cond->thread_wait_list;
+        while (p->next != node)
+            p = p->next;
+        p->next = node->next;
+    }
+    aos_mutex_unlock(&cond->wait_list_lock);
+
+    return BHT_OK;
+}
+
+int
+os_cond_wait(korp_cond *cond, korp_mutex *mutex)
+{
+    return os_cond_wait_internal(cond, mutex, false, 0);
+}
+
+int
+os_cond_reltimedwait(korp_cond *cond, korp_mutex *mutex, int useconds)
+{
+    if (useconds == BHT_WAIT_FOREVER)
+        return os_cond_wait_internal(cond, mutex, false, 0);
+    else
+        return os_cond_wait_internal(cond, mutex, true, useconds / 1000);
+}
+
+int
+os_cond_signal(korp_cond *cond)
+{
+    /* Signal the head wait node of wait list */
+    aos_mutex_lock(&cond->wait_list_lock, AOS_WAIT_FOREVER);
+    if (cond->thread_wait_list)
+        aos_sem_signal(&cond->thread_wait_list->sem);
+    aos_mutex_unlock(&cond->wait_list_lock);
+
+    return BHT_OK;
+}
+

core/shared/platform/alios/alios_time.c

@@ -0,0 +1,13 @@
+/*
+ * Copyright (C) 2019 Intel Corporation.  All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+ */
+
+#include "platform_api_vmcore.h"
+
+uint64
+os_time_get_boot_microsecond()
+{
+    return (uint64)aos_now_ms() * 1000;
+}
+

core/shared/platform/alios/bh_assert.c

@@ -1,52 +0,0 @@
-/*
- * Copyright (C) 2019 Intel Corporation.  All rights reserved.
- * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
- */
-
-#include "bh_platform.h"
-#include "bh_assert.h"
-#include <stdarg.h>
-#include <stdio.h>
-#include <stdlib.h>
-
-#ifdef BH_TEST
-#include <setjmp.h>
-#endif
-
-#ifdef BH_TEST
-/* for exception throwing */
-jmp_buf bh_test_jb;
-#endif
-
-void bh_assert_internal(int v, const char *file_name, int line_number, const char *expr_string)
-{
-  if(v) return;
-
-  if(!file_name) file_name = "NULL FILENAME";
-  if(!expr_string) expr_string = "NULL EXPR_STRING";
-
-  printf("\nASSERTION FAILED: %s, at FILE=%s, LINE=%d\n", expr_string, file_name, line_number);
-
-#ifdef BH_TEST
-  longjmp(bh_test_jb, 1);
-#endif
-
-  aos_reboot();
-}
-
-void bh_debug_internal(const char *file_name, int line_number, const char *fmt, ...)
-{
-#ifndef JEFF_TEST_VERIFIER
-  va_list args;
-
-  va_start(args, fmt);
-  bh_assert(file_name);
-
-  printf("\nDebug info FILE=%s, LINE=%d: ", file_name, line_number);
-  vprintf(fmt, args);
-
-  va_end(args);
-  printf("\n");
-#endif
-}
-

core/shared/platform/alios/bh_platform.h

@@ -1,131 +0,0 @@
-/*
- * Copyright (C) 2019 Intel Corporation.  All rights reserved.
- * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
- */
-
-#ifndef _BH_PLATFORM_H
-#define _BH_PLATFORM_H
-
-#include "bh_config.h"
-#include "bh_types.h"
-#include <aos/kernel.h>
-#include <inttypes.h>
-#include <stdbool.h>
-#include <stdarg.h>
-#include <ctype.h>
-#include <limits.h>
-#include <errno.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-
-#ifndef BH_PLATFORM_ALIOS_THINGS
-#define BH_PLATFORM_ALIOS_THINGS
-#endif
-
-#define BH_APPLET_PRESERVED_STACK_SIZE (2 * BH_KB)
-
-/* Default thread priority */
-#define BH_THREAD_DEFAULT_PRIORITY 30
-
-#define BH_ROUTINE_MODIFIER
-
-/* Invalid thread tid */
-#define INVALID_THREAD_ID NULL
-
-#define BH_WAIT_FOREVER AOS_WAIT_FOREVER
-
-typedef uint64_t uint64;
-typedef int64_t int64;
-
-typedef aos_task_t korp_thread;
-typedef korp_thread *korp_tid;
-typedef aos_task_t *aos_tid_t;
-typedef aos_mutex_t korp_mutex;
-typedef aos_sem_t korp_sem;
-
-struct bh_thread_wait_node;
-typedef struct bh_thread_wait_node *bh_thread_wait_list;
-typedef struct korp_cond {
-  aos_mutex_t wait_list_lock;
-  bh_thread_wait_list thread_wait_list;
-} korp_cond;
-
-typedef void* (*thread_start_routine_t)(void*);
-
-void *os_malloc(unsigned size);
-void *os_realloc(void *ptr, unsigned size);
-void os_free(void *ptr);
-
-/* Unit test framework is based on C++, where the declaration of
-   snprintf is different.  */
-#ifndef __cplusplus
-int snprintf(char *buffer, size_t count, const char *format, ...);
-#endif
-
-#ifndef NULL
-#define NULL ((void*)0)
-#endif
-
-/**
- * Return the offset of the given field in the given type.
- *
- * @param Type the type containing the filed
- * @param field the field in the type
- *
- * @return the offset of field in Type
- */
-#ifndef offsetof
-#define offsetof(Type, field) ((size_t)(&((Type *)0)->field))
-#endif
-
-#define bh_printf printf
-
-extern void bh_assert_internal(int v, const char *file_name, int line_number, const char *expr_string);
-#define bh_assert(expr) bh_assert_internal((int)(expr), __FILE__, __LINE__, # expr)
-
-/* math functions */
-double sqrt(double x);
-double floor(double x);
-double ceil(double x);
-double fmin(double x, double y);
-double fmax(double x, double y);
-double rint(double x);
-double fabs(double x);
-double trunc(double x);
-float floorf(float x);
-float ceilf(float x);
-float fminf(float x, float y);
-float fmaxf(float x, float y);
-float rintf(float x);
-float truncf(float x);
-int signbit(double x);
-int isnan(double x);
-
-int bh_platform_init();
-
-/* MMAP mode */
-enum {
-    MMAP_PROT_NONE = 0,
-    MMAP_PROT_READ = 1,
-    MMAP_PROT_WRITE = 2,
-    MMAP_PROT_EXEC = 4
-};
-
-/* MMAP flags */
-enum {
-    MMAP_MAP_NONE = 0,
-    /* Put the mapping into 0 to 2 G, supported only on x86_64 */
-    MMAP_MAP_32BIT = 1,
-    /* Don't interpret addr as a hint: place the mapping at exactly
-       that address. */
-    MMAP_MAP_FIXED = 2
-};
-
-void *bh_mmap(void *hint, unsigned int size, int prot, int flags);
-void bh_munmap(void *addr, uint32 size);
-int bh_mprotect(void *addr, uint32 size, int prot);
-void bh_dcache_flush();
-
-#endif /* end of _BH_PLATFORM_H */
-

core/shared/platform/alios/bh_platform_log.c

@@ -1,33 +0,0 @@
-/*
- * Copyright (C) 2019 Intel Corporation.  All rights reserved.
- * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
- */
-
-#include "bh_platform.h"
-#include <stdio.h>
-
-
-void bh_log_emit(const char *fmt, va_list ap)
-{
-  vprintf(fmt, ap);
-}
-
-int bh_fprintf(FILE *stream, const char *fmt, ...)
-{
-  (void)stream;
-  va_list ap;
-  int ret;
-
-  va_start(ap, fmt);
-  ret = vprintf(fmt, ap);
-  va_end(ap);
-
-  return ret;
-}
-
-int bh_fflush(void *stream)
-{
-  (void)stream;
-  return 0;
-}
-

core/shared/platform/alios/bh_thread.c

@@ -1,435 +0,0 @@
-/*
- * Copyright (C) 2019 Intel Corporation.  All rights reserved.
- * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
- */
-
-#include "bh_thread.h"
-#include "bh_assert.h"
-#include "bh_log.h"
-#include <stdio.h>
-#include <stdlib.h>
-
-
-struct bh_thread_data;
-typedef struct bh_thread_wait_node {
-  aos_sem_t sem;
-  bh_thread_wait_list next;
-} bh_thread_wait_node;
-
-typedef struct bh_thread_data {
-  /* Thread body */
-  aos_task_t thread;
-  /* Thread start routine */
-  thread_start_routine_t start_routine;
-  /* Thread start routine argument */
-  void *arg;
-  /* Thread local root */
-  void *tlr;
-  /* Wait node of current thread */
-  bh_thread_wait_node wait_node;
-  /* Lock for waiting list */
-  aos_mutex_t wait_list_lock;
-  /* Waiting list of other threads who are joining this thread */
-  bh_thread_wait_list thread_wait_list;
-} bh_thread_data;
-
-static bool is_thread_sys_inited = false;
-
-/* Thread data of supervisor thread */
-static bh_thread_data supervisor_thread_data;
-
-/* Thread data key */
-static aos_task_key_t thread_data_key;
-
-/* Thread name index */
-static int thread_name_index;
-
-int
-_vm_thread_sys_init()
-{
-  if (is_thread_sys_inited)
-    return BHT_OK;
-
-  if (aos_task_key_create(&thread_data_key) != 0)
-    return BHT_ERROR;
-
-  /* Initialize supervisor thread data */
-  memset(&supervisor_thread_data, 0, sizeof(supervisor_thread_data));
-
-  if (aos_sem_new(&supervisor_thread_data.wait_node.sem, 1) != 0) {
-    aos_task_key_delete(thread_data_key);
-    return BHT_ERROR;
-  }
-
-  if (aos_task_setspecific(thread_data_key, &supervisor_thread_data)) {
-    aos_sem_free(&supervisor_thread_data.wait_node.sem);
-    aos_task_key_delete(thread_data_key);
-    return BHT_ERROR;
-  }
-
-  is_thread_sys_inited = true;
-  return BHT_OK;
-}
-
-void
-vm_thread_sys_destroy()
-{
-  if (is_thread_sys_inited) {
-    aos_task_key_delete(thread_data_key);
-    aos_sem_free(&supervisor_thread_data.wait_node.sem);
-    is_thread_sys_inited = false;
-  }
-}
-
-static bh_thread_data *
-thread_data_current()
-{
-  return aos_task_getspecific(thread_data_key);
-}
-
-static void
-vm_thread_cleanup(void)
-{
-  bh_thread_data *thread_data = thread_data_current();
-  bh_thread_wait_list thread_wait_list;
-  aos_mutex_t *wait_list_lock;
-  aos_sem_t *wait_node_sem;
-
-  bh_assert(thread_data != NULL);
-  wait_list_lock = &thread_data->wait_list_lock;
-  thread_wait_list = thread_data->thread_wait_list;
-  wait_node_sem = &thread_data->wait_node.sem;
-
-  /* Free thread data firstly */
-  BH_FREE(thread_data);
-
-  aos_mutex_lock(wait_list_lock, AOS_WAIT_FOREVER);
-  if (thread_wait_list) {
-    /* Signal each joining thread */
-    bh_thread_wait_list head = thread_wait_list;
-    while (head) {
-      bh_thread_wait_list next = head->next;
-      aos_sem_signal(&head->sem);
-      head = next;
-    }
-  }
-  aos_mutex_unlock(wait_list_lock);
-
-  /* Free sem and lock */
-  aos_sem_free(wait_node_sem);
-  aos_mutex_free(wait_list_lock);
-}
-
-static void
-vm_thread_wrapper(void *arg)
-{
-  bh_thread_data *thread_data = arg;
-
-  /* Set thread custom data */
-  if (!aos_task_setspecific(thread_data_key, thread_data))
-    thread_data->start_routine(thread_data->arg);
-
-  vm_thread_cleanup();
-}
-
-int
-_vm_thread_create(korp_tid *p_tid, thread_start_routine_t start,
-                  void *arg, unsigned int stack_size)
-{
-  return _vm_thread_create_with_prio(p_tid, start, arg, stack_size,
-                                     BH_THREAD_DEFAULT_PRIORITY);
-}
-
-int
-_vm_thread_create_with_prio(korp_tid *p_tid, thread_start_routine_t start,
-                            void *arg, unsigned int stack_size, int prio)
-{
-  bh_thread_data *thread_data;
-  char thread_name[32];
-
-  if (!p_tid || !stack_size)
-    return BHT_ERROR;
-
-  /* Create and initialize thread data */
-  if (!(thread_data = BH_MALLOC(sizeof(bh_thread_data))))
-    return BHT_ERROR;
-
-  memset(thread_data, 0, sizeof(bh_thread_data));
-
-  thread_data->start_routine = start;
-  thread_data->arg = arg;
-
-  if (aos_sem_new(&thread_data->wait_node.sem, 1) != 0)
-    goto fail1;
-
-  if (aos_mutex_new(&thread_data->wait_list_lock))
-    goto fail2;
-
-  snprintf(thread_name, sizeof(thread_name), "%s%d",
-           "wasm-thread-", ++thread_name_index);
-
-  /* Create the thread */
-  if (aos_task_new_ext((aos_task_t*)thread_data, thread_name,
-                        vm_thread_wrapper, thread_data,
-                        stack_size, prio))
-    goto fail3;
-
-  aos_msleep(10);
-  *p_tid = (korp_tid)thread_data;
-  return BHT_OK;
-
-fail3:
-  aos_mutex_free(&thread_data->wait_list_lock);
-fail2:
-  aos_sem_free(&thread_data->wait_node.sem);
-fail1:
-  BH_FREE(thread_data);
-  return BHT_ERROR;
-}
-
-korp_tid
-_vm_self_thread()
-{
-  return (korp_tid)aos_task_getspecific(thread_data_key);
-}
-
-void
-vm_thread_exit(void * code)
-{
-  vm_thread_cleanup();
-  aos_task_exit((int)(intptr_t)code);
-}
-
-int
-_vm_thread_cancel (korp_tid thread)
-{
-  /* TODO */
-  return 0;
-}
-
-int
-_vm_thread_join (korp_tid thread, void **value_ptr, int mills)
-{
-  (void)value_ptr;
-  bh_thread_data *thread_data, *curr_thread_data;
-
-  /* Get thread data of current thread */
-  curr_thread_data = thread_data_current();
-  curr_thread_data->wait_node.next = NULL;
-
-  /* Get thread data */
-  thread_data = (bh_thread_data*)thread;
-
-  aos_mutex_lock(&thread_data->wait_list_lock, AOS_WAIT_FOREVER);
-  if (!thread_data->thread_wait_list)
-    thread_data->thread_wait_list = &curr_thread_data->wait_node;
-  else {
-    /* Add to end of waiting list */
-    bh_thread_wait_node *p = thread_data->thread_wait_list;
-    while (p->next)
-      p = p->next;
-    p->next = &curr_thread_data->wait_node;
-  }
-  aos_mutex_unlock(&thread_data->wait_list_lock);
-
-  /* Wait the sem */
-  aos_sem_wait(&curr_thread_data->wait_node.sem, mills);
-
-  return BHT_OK;
-}
-
-int
-_vm_thread_detach (korp_tid thread)
-{
-  (void)thread;
-  return BHT_OK;
-}
-
-void *
-_vm_tls_get(unsigned idx)
-{
-  (void)idx;
-  bh_thread_data *thread_data;
-
-  bh_assert (idx == 0);
-  thread_data = thread_data_current();
-
-  return thread_data ? thread_data->tlr : NULL;
-}
-
-int
-_vm_tls_put(unsigned idx, void * tls)
-{
-  bh_thread_data *thread_data;
-
-  (void)idx;
-  bh_assert (idx == 0);
-  thread_data = thread_data_current();
-  bh_assert (thread_data != NULL);
-
-  thread_data->tlr = tls;
-  return BHT_OK;
-}
-
-int
-_vm_mutex_init(korp_mutex *mutex)
-{
-  return aos_mutex_new(mutex) == 0 ? BHT_OK : BHT_ERROR;
-}
-
-int
-_vm_recursive_mutex_init(korp_mutex *mutex)
-{
-  return aos_mutex_new(mutex) == 0 ? BHT_OK : BHT_ERROR;
-}
-
-int
-_vm_mutex_destroy(korp_mutex *mutex)
-{
-  aos_mutex_free(mutex);
-  return BHT_OK;
-}
-
-void
-vm_mutex_lock(korp_mutex *mutex)
-{
-  aos_mutex_lock(mutex, AOS_WAIT_FOREVER);
-}
-
-int
-vm_mutex_trylock(korp_mutex *mutex)
-{
-  return aos_mutex_lock(mutex, AOS_NO_WAIT);
-}
-
-void vm_mutex_unlock(korp_mutex *mutex)
-{
-  aos_mutex_unlock(mutex);
-}
-
-int _vm_sem_init(korp_sem* sem, unsigned int c)
-{
-  return aos_sem_new(sem, c) == 0 ? BHT_OK : BHT_ERROR;
-}
-
-int _vm_sem_destroy(korp_sem *sem)
-{
-  aos_sem_free(sem);
-  return BHT_OK;
-}
-
-int _vm_sem_wait(korp_sem *sem)
-{
-  return aos_sem_wait(sem, AOS_WAIT_FOREVER);
-}
-
-int _vm_sem_reltimedwait(korp_sem *sem, int mills)
-{
-  return aos_sem_wait(sem, mills);
-}
-
-int _vm_sem_post(korp_sem *sem)
-{
-  aos_sem_signal(sem);
-  return BHT_OK;
-}
-
-int
-_vm_cond_init(korp_cond *cond)
-{
-  if (aos_mutex_new(&cond->wait_list_lock) != 0)
-    return BHT_ERROR;
-
-  cond->thread_wait_list = NULL;
-  return BHT_OK;
-}
-
-int
-_vm_cond_destroy(korp_cond *cond)
-{
-  aos_mutex_free(&cond->wait_list_lock);
-  return BHT_OK;
-}
-
-static int
-vm_cond_wait_internal(korp_cond *cond, korp_mutex *mutex,
-                      bool timed, int mills)
-{
-  bh_thread_wait_node *node = &thread_data_current()->wait_node;
-
-  node->next = NULL;
-
-  aos_mutex_lock(&cond->wait_list_lock, AOS_WAIT_FOREVER);
-  if (!cond->thread_wait_list)
-    cond->thread_wait_list = node;
-  else {
-    /* Add to end of wait list */
-    bh_thread_wait_node *p = cond->thread_wait_list;
-    while (p->next)
-      p = p->next;
-    p->next = node;
-  }
-  aos_mutex_unlock(&cond->wait_list_lock);
-
-  /* Unlock mutex, wait sem and lock mutex again */
-  aos_mutex_unlock(mutex);
-  aos_sem_wait(&node->sem, timed ? mills : AOS_WAIT_FOREVER);
-  aos_mutex_lock(mutex, AOS_WAIT_FOREVER);
-
-  /* Remove wait node from wait list */
-  aos_mutex_lock(&cond->wait_list_lock, AOS_WAIT_FOREVER);
-  if (cond->thread_wait_list == node)
-    cond->thread_wait_list = node->next;
-  else {
-    /* Remove from the wait list */
-    bh_thread_wait_node *p = cond->thread_wait_list;
-    while (p->next != node)
-      p = p->next;
-    p->next = node->next;
-  }
-  aos_mutex_unlock(&cond->wait_list_lock);
-
-  return BHT_OK;
-}
-
-int
-_vm_cond_wait(korp_cond *cond, korp_mutex *mutex)
-{
-  return vm_cond_wait_internal(cond, mutex, false, 0);
-}
-
-int
-_vm_cond_reltimedwait(korp_cond *cond, korp_mutex *mutex, int mills)
-{
-  return vm_cond_wait_internal(cond, mutex, true, mills);
-}
-
-int
-_vm_cond_signal(korp_cond *cond)
-{
-  /* Signal the head wait node of wait list */
-  aos_mutex_lock(&cond->wait_list_lock, AOS_WAIT_FOREVER);
-  if (cond->thread_wait_list)
-    aos_sem_signal(&cond->thread_wait_list->sem);
-  aos_mutex_unlock(&cond->wait_list_lock);
-
-  return BHT_OK;
-}
-
-int
-_vm_cond_broadcast (korp_cond *cond)
-{
-  /* Signal each wait node of wait list */
-  aos_mutex_lock(&cond->wait_list_lock, AOS_WAIT_FOREVER);
-  if (cond->thread_wait_list) {
-    bh_thread_wait_node *p = cond->thread_wait_list;
-    while (p) {
-      aos_sem_signal(&p->sem);
-      p = p->next;
-    }
-  }
-  aos_mutex_unlock(&cond->wait_list_lock);
-
-  return BHT_OK;
-}
-

core/shared/platform/alios/bh_time.c

@@ -1,37 +0,0 @@
-/*
- * Copyright (C) 2019 Intel Corporation.  All rights reserved.
- * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
- */
-
-#include "bh_time.h"
-
-/*
- * This function returns milliseconds per tick.
- * @return milliseconds per tick.
- */
-uint64 _bh_time_get_tick_millisecond()
-{
-  return aos_get_hz() / 1000;
-}
-
-/*
- * This function returns milliseconds after boot.
- * @return milliseconds after boot.
- */
-uint64 _bh_time_get_boot_millisecond()
-{
-  return (uint64)aos_now_ms();
-}
-
-uint64 _bh_time_get_millisecond_from_1970()
-{
-  return (uint64)aos_now_ms();
-}
-
-size_t
-_bh_time_strftime (char *str, size_t max, const char *format, int64 time)
-{
-  str = aos_now_time_str(str, max);
-  return str ? strlen(str) + 1 : 0;
-}
-

core/shared/platform/alios/platform_internal.h

@@ -0,0 +1,63 @@
+/*
+ * Copyright (C) 2019 Intel Corporation.  All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+ */
+
+#ifndef _PLATFORM_INTERNAL_H
+#define _PLATFORM_INTERNAL_H
+
+#include <aos/kernel.h>
+#include <inttypes.h>
+#include <stdbool.h>
+#include <stdarg.h>
+#include <ctype.h>
+#include <limits.h>
+#include <errno.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#ifndef BH_PLATFORM_ALIOS_THINGS
+#define BH_PLATFORM_ALIOS_THINGS
+#endif
+
+#define BH_APPLET_PRESERVED_STACK_SIZE (2 * BH_KB)
+
+/* Default thread priority */
+#define BH_THREAD_DEFAULT_PRIORITY 30
+
+typedef aos_task_t korp_thread;
+typedef korp_thread *korp_tid;
+typedef aos_task_t *aos_tid_t;
+typedef aos_mutex_t korp_mutex;
+
+struct os_thread_wait_node;
+typedef struct os_thread_wait_node *os_thread_wait_list;
+typedef struct korp_cond {
+  aos_mutex_t wait_list_lock;
+  os_thread_wait_list thread_wait_list;
+} korp_cond;
+
+#define os_printf  printf
+#define os_vprintf vprintf
+
+/* math functions which are not provided by os*/
+double sqrt(double x);
+double floor(double x);
+double ceil(double x);
+double fmin(double x, double y);
+double fmax(double x, double y);
+double rint(double x);
+double fabs(double x);
+double trunc(double x);
+float floorf(float x);
+float ceilf(float x);
+float fminf(float x, float y);
+float fmaxf(float x, float y);
+float rintf(float x);
+float truncf(float x);
+int signbit(double x);
+int isnan(double x);
+
+#endif /* end of _BH_PLATFORM_H */
+

core/shared/platform/alios/shared_platform.cmake

@@ -1,13 +1,16 @@
-# Copyright (C) 2019 Intel Corporation.  All rights reserved.
-# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-
-set (PLATFORM_SHARED_DIR ${CMAKE_CURRENT_LIST_DIR})
-
-include_directories(${PLATFORM_SHARED_DIR})
-include_directories(${PLATFORM_SHARED_DIR}/../include)
-
-
-file (GLOB_RECURSE source_all ${PLATFORM_SHARED_DIR}/*.c)
-
-set (PLATFORM_SHARED_SOURCE ${source_all})
-
+# Copyright (C) 2019 Intel Corporation.  All rights reserved.
+# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+set (PLATFORM_SHARED_DIR ${CMAKE_CURRENT_LIST_DIR})
+
+add_definitions(-DBH_PLATFORM_ALIOS_THINGS)
+
+include_directories(${PLATFORM_SHARED_DIR})
+include_directories(${PLATFORM_SHARED_DIR}/../include)
+
+include (${CMAKE_CURRENT_LIST_DIR}/../common/math/platform_api_math.cmake)
+
+file (GLOB_RECURSE source_all ${PLATFORM_SHARED_DIR}/*.c)
+
+set (PLATFORM_SHARED_SOURCE ${source_all} ${PLATFORM_COMMON_MATH_SOURCE})
+

core/shared/platform/android/bh_assert.c

@@ -1,58 +0,0 @@
-/*
- * Copyright (C) 2019 Intel Corporation.  All rights reserved.
- * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
- */
-
-#include "bh_platform.h"
-#include "bh_assert.h"
-#include <stdarg.h>
-#include <stdio.h>
-#include <stdlib.h>
-
-#ifdef BH_TEST
-#include <setjmp.h>
-#endif
-
-#ifdef BH_TEST
-/* for exception throwing */
-jmp_buf bh_test_jb;
-#endif
-
-void bh_assert_internal(int v, const char *file_name, int line_number,
-        const char *expr_string)
-{
-    if (v)
-        return;
-
-    if (!file_name)
-        file_name = "NULL FILENAME";
-    if (!expr_string)
-        expr_string = "NULL EXPR_STRING";
-
-    printf("\nASSERTION FAILED: %s, at FILE=%s, LINE=%d\n", expr_string,
-            file_name, line_number);
-
-#ifdef BH_TEST
-    longjmp(bh_test_jb, 1);
-#endif
-
-    abort();
-}
-
-void bh_debug_internal(const char *file_name, int line_number, const char *fmt,
-        ...)
-{
-#ifndef JEFF_TEST_VERIFIER
-    va_list args;
-
-    va_start(args, fmt);
-    bh_assert(file_name);
-
-    printf("\nDebug info FILE=%s, LINE=%d: ", file_name, line_number);
-    vprintf(fmt, args);
-
-    va_end(args);
-    printf("\n");
-#endif
-}
-

core/shared/platform/android/bh_platform.c

@@ -1,182 +0,0 @@
-/*
- * Copyright (C) 2019 Intel Corporation.  All rights reserved.
- * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
- */
-
-#include "bh_platform.h"
-#include "bh_common.h"
-#include "bh_assert.h"
-
-#include <sys/stat.h>
-#include <fcntl.h>
-#include <unistd.h>
-#include <sys/mman.h>
-
-int
-bh_platform_init()
-{
-    return 0;
-}
-
-void *
-os_malloc(unsigned size)
-{
-    return malloc(size);
-}
-
-void *
-os_realloc(void *ptr, unsigned size)
-{
-    return realloc(ptr, size);
-}
-
-void
-os_free(void *ptr)
-{
-    free(ptr);
-}
-
-char*
-bh_read_file_to_buffer(const char *filename, uint32 *ret_size)
-{
-    char *buffer;
-    int file;
-    uint32 file_size, read_size;
-    struct stat stat_buf;
-
-    if (!filename || !ret_size) {
-        printf("Read file to buffer failed: invalid filename or ret size.\n");
-        return NULL;
-    }
-
-    if ((file = open(filename, O_RDONLY, 0)) == -1) {
-        printf("Read file to buffer failed: open file %s failed.\n",
-               filename);
-        return NULL;
-    }
-
-    if (fstat(file, &stat_buf) != 0) {
-        printf("Read file to buffer failed: fstat file %s failed.\n",
-               filename);
-        close(file);
-        return NULL;
-    }
-
-    file_size = (uint32)stat_buf.st_size;
-
-    if (!(buffer = BH_MALLOC(file_size))) {
-        printf("Read file to buffer failed: alloc memory failed.\n");
-        close(file);
-        return NULL;
-    }
-
-    read_size = (uint32)read(file, buffer, file_size);
-    close(file);
-
-    if (read_size < file_size) {
-        printf("Read file to buffer failed: read file content failed.\n");
-        BH_FREE(buffer);
-        return NULL;
-    }
-
-    *ret_size = file_size;
-    return buffer;
-}
-
-void *
-bh_mmap(void *hint, uint32 size, int prot, int flags)
-{
-    int map_prot = PROT_NONE;
-    int map_flags = MAP_ANONYMOUS | MAP_PRIVATE;
-    uint64 request_size, page_size;
-    uint8 *addr, *addr_aligned;
-    uint32 i;
-
-    /* align to 2M if no less than 2M, else align to 4K */
-    page_size = size < 2 * 1024 * 1024 ? 4096 : 2 * 1024 * 1024;
-    request_size = (size + page_size - 1) & ~(page_size - 1);
-    request_size += page_size;
-
-    if (request_size >= UINT32_MAX)
-        return NULL;
-
-    if (prot & MMAP_PROT_READ)
-        map_prot |= PROT_READ;
-
-    if (prot & MMAP_PROT_WRITE)
-        map_prot |= PROT_WRITE;
-
-    if (prot & MMAP_PROT_EXEC)
-        map_prot |= PROT_EXEC;
-
-#if defined(BUILD_TARGET_X86_64) || defined(BUILD_TARGET_AMD_64)
-    if (flags & MMAP_MAP_32BIT)
-        map_flags |= MAP_32BIT;
-#endif
-
-    if (flags & MMAP_MAP_FIXED)
-        map_flags |= MAP_FIXED;
-
-    /* try 5 times */
-    for (i = 0; i < 5; i ++) {
-        addr = mmap(hint, size, map_prot, map_flags, -1, 0);
-        if (addr != MAP_FAILED)
-            break;
-    }
-    if (addr == MAP_FAILED)
-        return NULL;
-
-    addr_aligned = (uint8*)(uintptr_t)
-        (((uint64)(uintptr_t)addr + page_size - 1) & ~(page_size - 1));
-
-    /* Unmap memory allocated before the aligned base address */
-    if (addr != addr_aligned) {
-        uint32 prefix_size = (uint32)(addr_aligned - addr);
-        munmap(addr, prefix_size);
-        request_size -= prefix_size;
-    }
-
-    /* Unmap memory allocated after the potentially unaligned end */
-    if (size != request_size) {
-        uint32 suffix_size = (uint32)(request_size - size);
-        munmap(addr_aligned + size, suffix_size);
-        request_size -= size;
-    }
-
-    if (size >= 2 * 1024 * 1024) {
-        /* Try to use huge page to improve performance */
-        if (!madvise(addr, size, MADV_HUGEPAGE))
-            /* make huge page become effective */
-            memset(addr, 0, size);
-    }
-
-    return addr_aligned;
-}
-
-void
-bh_munmap(void *addr, uint32 size)
-{
-    if (addr)
-        munmap(addr, size);
-}
-
-int
-bh_mprotect(void *addr, uint32 size, int prot)
-{
-    int map_prot = PROT_NONE;
-
-    if (!addr)
-        return 0;
-
-    if (prot & MMAP_PROT_READ)
-        map_prot |= PROT_READ;
-
-    if (prot & MMAP_PROT_WRITE)
-        map_prot |= PROT_WRITE;
-
-    if (prot & MMAP_PROT_EXEC)
-        map_prot |= PROT_EXEC;
-
-    return mprotect(addr, size, map_prot);
-}
-

core/shared/platform/android/bh_platform.h

@@ -1,125 +0,0 @@
-/*
- * Copyright (C) 2019 Intel Corporation.  All rights reserved.
- * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
- */
-
-#ifndef _BH_PLATFORM_H
-#define _BH_PLATFORM_H
-
-#include "bh_config.h"
-#include "bh_types.h"
-#include <inttypes.h>
-#include <stdbool.h>
-#include <assert.h>
-#include <time.h>
-#include <string.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <math.h>
-#include <stdarg.h>
-#include <ctype.h>
-#include <pthread.h>
-#include <semaphore.h>
-#include <limits.h>
-#include <fcntl.h>
-#include <errno.h>
-#include <sys/socket.h>
-#include <sys/stat.h>
-#include <netinet/in.h>
-#include <android/log.h>
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-typedef uint64_t uint64;
-typedef int64_t int64;
-
-#ifndef BH_PLATFORM_ANDROID
-#define BH_PLATFORM_ANDROID
-#endif
-
-#define _STACK_SIZE_ADJUSTMENT (32 * 1024)
-
-/* Stack size of applet threads's native part.  */
-#define BH_APPLET_PRESERVED_STACK_SIZE      (8 * 1024 + _STACK_SIZE_ADJUSTMENT)
-
-/* Default thread priority */
-#define BH_THREAD_DEFAULT_PRIORITY 0
-
-#define BH_ROUTINE_MODIFIER
-
-#define BHT_TIMEDOUT ETIMEDOUT
-
-#define INVALID_THREAD_ID 0xFFffFFff
-
-typedef pthread_t korp_tid;
-typedef pthread_mutex_t korp_mutex;
-typedef sem_t korp_sem;
-typedef pthread_cond_t korp_cond;
-typedef pthread_t korp_thread;
-typedef void* (*thread_start_routine_t)(void*);
-
-void *os_malloc(unsigned size);
-void *os_realloc(void *ptr, unsigned size);
-void os_free(void *ptr);
-
-#define bh_printf(...) (__android_log_print(ANDROID_LOG_INFO, "wasm_runtime::", __VA_ARGS__))
-
-int snprintf(char *buffer, size_t count, const char *format, ...);
-double fmod(double x, double y);
-float fmodf(float x, float y);
-double sqrt(double x);
-
-#define BH_WAIT_FOREVER 0xFFFFFFFF
-
-#ifndef NULL
-#  define NULL ((void*) 0)
-#endif
-
-/**
- * Return the offset of the given field in the given type.
- *
- * @param Type the type containing the filed
- * @param field the field in the type
- *
- * @return the offset of field in Type
- */
-#ifndef offsetof
-#define offsetof(Type, field) ((size_t)(&((Type *)0)->field))
-#endif
-
-#define bh_assert assert
-
-char *bh_read_file_to_buffer(const char *filename, uint32 *ret_size);
-
-int bh_platform_init();
-
-/* MMAP mode */
-enum {
-    MMAP_PROT_NONE = 0,
-    MMAP_PROT_READ = 1,
-    MMAP_PROT_WRITE = 2,
-    MMAP_PROT_EXEC = 4
-};
-
-/* MMAP flags */
-enum {
-    MMAP_MAP_NONE = 0,
-    /* Put the mapping into 0 to 2 G, supported only on x86_64 */
-    MMAP_MAP_32BIT = 1,
-    /* Don't interpret addr as a hint: place the mapping at exactly
-       that address. */
-    MMAP_MAP_FIXED = 2
-};
-
-void *bh_mmap(void *hint, unsigned int size, int prot, int flags);
-void bh_munmap(void *addr, uint32 size);
-int bh_mprotect(void *addr, uint32 size, int prot);
-#define bh_dcache_flush() (void)0
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif

core/shared/platform/android/bh_thread.c

@@ -1,394 +0,0 @@
-/*
- * Copyright (C) 2019 Intel Corporation.  All rights reserved.
- * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
- */
-
-#include "bh_thread.h"
-#include "bh_assert.h"
-#include "bh_log.h"
-#include <stdio.h>
-#include <stdlib.h>
-#include <sys/time.h>
-
-static bool is_thread_sys_inited = false;
-
-static korp_mutex thread_list_lock;
-static pthread_key_t thread_local_storage_key[BH_MAX_TLS_NUM];
-
-int _vm_thread_sys_init()
-{
-    unsigned i, j;
-    int ret;
-
-    if (is_thread_sys_inited)
-        return 0;
-
-    for (i = 0; i < BH_MAX_TLS_NUM; i++) {
-        ret = pthread_key_create(&thread_local_storage_key[i], NULL);
-        if (ret)
-            goto fail;
-    }
-
-    ret = vm_mutex_init(&thread_list_lock);
-    if (ret)
-        goto fail;
-
-    is_thread_sys_inited = true;
-    return 0;
-
-    fail: for (j = 0; j < i; j++)
-        pthread_key_delete(thread_local_storage_key[j]);
-    return -1;
-}
-
-void vm_thread_sys_destroy(void)
-{
-    if (is_thread_sys_inited) {
-        unsigned i;
-        for (i = 0; i < BH_MAX_TLS_NUM; i++)
-            pthread_key_delete(thread_local_storage_key[i]);
-        vm_mutex_destroy(&thread_list_lock);
-        is_thread_sys_inited = false;
-    }
-}
-
-typedef struct {
-    thread_start_routine_t start;
-    void* stack;
-    uint32 stack_size;
-    void* arg;
-} thread_wrapper_arg;
-
-static void *vm_thread_wrapper(void *arg)
-{
-    thread_wrapper_arg * targ = arg;
-    LOG_VERBOSE("THREAD CREATE 0x%08x\n", &targ);
-    targ->stack = (void *)((uintptr_t)(&arg) & (uintptr_t)~0xfff);
-    _vm_tls_put(1, targ);
-    targ->start(targ->arg);
-    BH_FREE(targ);
-    _vm_tls_put(1, NULL);
-    return NULL;
-}
-
-int _vm_thread_create_with_prio(korp_tid *tid, thread_start_routine_t start,
-                                void *arg, unsigned int stack_size, int prio)
-{
-    (void)prio;
-    pthread_attr_t tattr;
-    thread_wrapper_arg *targ;
-
-    bh_assert(stack_size > 0);
-    bh_assert(tid);
-    bh_assert(start);
-
-    *tid = INVALID_THREAD_ID;
-
-    pthread_attr_init(&tattr);
-    pthread_attr_setdetachstate(&tattr, PTHREAD_CREATE_JOINABLE);
-    if (pthread_attr_setstacksize(&tattr, stack_size) != 0) {
-        bh_debug("Invalid thread stack size %u. Min stack size on Linux = %u",
-                stack_size, PTHREAD_STACK_MIN);
-        pthread_attr_destroy(&tattr);
-        return BHT_ERROR;
-    }
-
-    targ = (thread_wrapper_arg*) BH_MALLOC(sizeof(*targ));
-    if (!targ) {
-        pthread_attr_destroy(&tattr);
-        return BHT_ERROR;
-    }
-
-    targ->start = start;
-    targ->arg = arg;
-    targ->stack_size = stack_size;
-
-    if (pthread_create(tid, &tattr, vm_thread_wrapper, targ) != 0) {
-        pthread_attr_destroy(&tattr);
-        BH_FREE(targ);
-        return BHT_ERROR;
-    }
-
-    pthread_attr_destroy(&tattr);
-    return BHT_OK;
-}
-
-int _vm_thread_create(korp_tid *tid, thread_start_routine_t start, void *arg,
-                      unsigned int stack_size)
-{
-    return _vm_thread_create_with_prio(tid, start, arg, stack_size,
-                                       BH_THREAD_DEFAULT_PRIORITY);
-}
-
-korp_tid _vm_self_thread()
-{
-    return (korp_tid) pthread_self();
-}
-
-void vm_thread_exit(void * code)
-{
-    BH_FREE(_vm_tls_get(1));
-    _vm_tls_put(1, NULL);
-    pthread_exit(code);
-}
-
-void *_vm_tls_get(unsigned idx)
-{
-    bh_assert(idx < BH_MAX_TLS_NUM);
-    return pthread_getspecific(thread_local_storage_key[idx]);
-}
-
-int _vm_tls_put(unsigned idx, void * tls)
-{
-    bh_assert(idx < BH_MAX_TLS_NUM);
-    pthread_setspecific(thread_local_storage_key[idx], tls);
-    return BHT_OK;
-}
-
-int _vm_mutex_init(korp_mutex *mutex)
-{
-    return pthread_mutex_init(mutex, NULL) == 0 ? BHT_OK : BHT_ERROR;
-}
-
-int _vm_recursive_mutex_init(korp_mutex *mutex)
-{
-    int ret;
-
-    pthread_mutexattr_t mattr;
-
-    bh_assert(mutex);
-    ret = pthread_mutexattr_init(&mattr);
-    if (ret)
-        return BHT_ERROR;
-
-    pthread_mutexattr_settype(&mattr, PTHREAD_MUTEX_RECURSIVE_NP);
-    ret = pthread_mutex_init(mutex, &mattr);
-    pthread_mutexattr_destroy(&mattr);
-
-    return ret == 0 ? BHT_OK : BHT_ERROR;
-}
-
-int _vm_mutex_destroy(korp_mutex *mutex)
-{
-    int ret;
-
-    bh_assert(mutex);
-    ret = pthread_mutex_destroy(mutex);
-
-    return ret == 0 ? BHT_OK : BHT_ERROR;
-}
-
-/* Returned error (EINVAL, EAGAIN and EDEADLK) from
- locking the mutex indicates some logic error present in
- the program somewhere.
- Don't try to recover error for an existing unknown error.*/
-void vm_mutex_lock(korp_mutex *mutex)
-{
-    int ret;
-
-    bh_assert(mutex);
-    ret = pthread_mutex_lock(mutex);
-    if (0 != ret) {
-        printf("vm mutex lock failed (ret=%d)!\n", ret);
-        exit(-1);
-    }
-}
-
-int vm_mutex_trylock(korp_mutex *mutex)
-{
-    int ret;
-
-    bh_assert(mutex);
-    ret = pthread_mutex_trylock(mutex);
-
-    return ret == 0 ? BHT_OK : BHT_ERROR;
-}
-
-/* Returned error (EINVAL, EAGAIN and EPERM) from
- unlocking the mutex indicates some logic error present
- in the program somewhere.
- Don't try to recover error for an existing unknown error.*/
-void vm_mutex_unlock(korp_mutex *mutex)
-{
-    int ret;
-
-    bh_assert(mutex);
-    ret = pthread_mutex_unlock(mutex);
-    if (0 != ret) {
-        printf("vm mutex unlock failed (ret=%d)!\n", ret);
-        exit(-1);
-    }
-}
-
-int _vm_sem_init(korp_sem* sem, unsigned int c)
-{
-    int ret;
-
-    bh_assert(sem);
-    ret = sem_init(sem, 0, c);
-
-    return ret == 0 ? BHT_OK : BHT_ERROR;
-}
-
-int _vm_sem_destroy(korp_sem *sem)
-{
-    int ret;
-
-    bh_assert(sem);
-    ret = sem_destroy(sem);
-
-    return ret == 0 ? BHT_OK : BHT_ERROR;
-}
-
-int _vm_sem_wait(korp_sem *sem)
-{
-    int ret;
-
-    bh_assert(sem);
-
-    ret = sem_wait(sem);
-
-    return ret == 0 ? BHT_OK : BHT_ERROR;
-}
-
-int _vm_sem_reltimedwait(korp_sem *sem, int mills)
-{
-    int ret = BHT_OK;
-
-    struct timespec timeout;
-    const int mills_per_sec = 1000;
-    const int mills_to_nsec = 1E6;
-
-    bh_assert(sem);
-
-    if (mills == (int)BHT_WAIT_FOREVER) {
-        ret = sem_wait(sem);
-    } else {
-
-        timeout.tv_sec = mills / mills_per_sec;
-        timeout.tv_nsec = (mills % mills_per_sec) * mills_to_nsec;
-        timeout.tv_sec += time(NULL);
-
-        ret = sem_timedwait(sem, &timeout);
-    }
-
-    if (ret != BHT_OK) {
-        if (errno == BHT_TIMEDOUT) {
-            ret = BHT_TIMEDOUT;
-            errno = 0;
-        } else {
-            bh_debug("Faliure happens when timed wait is called");
-            bh_assert(0);
-        }
-    }
-
-    return ret;
-}
-
-int _vm_sem_post(korp_sem *sem)
-{
-    bh_assert(sem);
-
-    return sem_post(sem) == 0 ? BHT_OK : BHT_ERROR;
-}
-
-int _vm_cond_init(korp_cond *cond)
-{
-    bh_assert(cond);
-
-    if (pthread_cond_init(cond, NULL) != BHT_OK)
-        return BHT_ERROR;
-
-    return BHT_OK;
-}
-
-int _vm_cond_destroy(korp_cond *cond)
-{
-    bh_assert(cond);
-
-    if (pthread_cond_destroy(cond) != BHT_OK)
-        return BHT_ERROR;
-
-    return BHT_OK;
-}
-
-int _vm_cond_wait(korp_cond *cond, korp_mutex *mutex)
-{
-    bh_assert(cond);
-    bh_assert(mutex);
-
-    if (pthread_cond_wait(cond, mutex) != BHT_OK)
-        return BHT_ERROR;
-
-    return BHT_OK;
-}
-
-static void msec_nsec_to_abstime(struct timespec *ts, int64 msec, int32 nsec)
-{
-    struct timeval tv;
-
-    gettimeofday(&tv, NULL);
-
-    ts->tv_sec = (long int)(tv.tv_sec + msec / 1000);
-    ts->tv_nsec = (long int)(tv.tv_usec * 1000 + (msec % 1000) * 1000000 + nsec);
-
-    if (ts->tv_nsec >= 1000000000L) {
-        ts->tv_sec++;
-        ts->tv_nsec -= 1000000000L;
-    }
-}
-
-int _vm_cond_reltimedwait(korp_cond *cond, korp_mutex *mutex, int mills)
-{
-    int ret;
-    struct timespec abstime;
-
-    if (mills == (int)BHT_WAIT_FOREVER)
-        ret = pthread_cond_wait(cond, mutex);
-    else {
-        msec_nsec_to_abstime(&abstime, mills, 0);
-        ret = pthread_cond_timedwait(cond, mutex, &abstime);
-    }
-
-    if (ret != BHT_OK && ret != BHT_TIMEDOUT)
-        return BHT_ERROR;
-
-    return BHT_OK;
-}
-
-int _vm_cond_signal(korp_cond *cond)
-{
-    bh_assert(cond);
-
-    if (pthread_cond_signal(cond) != BHT_OK)
-        return BHT_ERROR;
-
-    return BHT_OK;
-}
-
-int _vm_cond_broadcast(korp_cond *cond)
-{
-    bh_assert(cond);
-
-    if (pthread_cond_broadcast(cond) != BHT_OK)
-        return BHT_ERROR;
-
-    return BHT_OK;
-}
-
-int _vm_thread_cancel(korp_tid thread)
-{
-    return pthread_kill(thread, SIGABRT);
-}
-
-int _vm_thread_join(korp_tid thread, void **value_ptr, int mills)
-{
-    (void)mills;
-    return pthread_join(thread, value_ptr);
-}
-
-int _vm_thread_detach(korp_tid thread)
-{
-    return pthread_detach(thread);
-}
-

core/shared/platform/android/bh_time.c

@@ -1,71 +0,0 @@
-/*
- * Copyright (C) 2019 Intel Corporation.  All rights reserved.
- * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
- */
-
-#include "bh_time.h"
-
-#include <unistd.h>
-#include <stdio.h>
-#include <sys/time.h>
-
-/*
- * This function returns milliseconds per tick.
- * @return milliseconds per tick.
- */
-uint64 _bh_time_get_tick_millisecond()
-{
-    return (uint64)sysconf(_SC_CLK_TCK);
-}
-
-/*
- * This function returns milliseconds after boot.
- * @return milliseconds after boot.
- */
-uint64 _bh_time_get_boot_millisecond()
-{
-    struct timespec ts;
-    if (clock_gettime(CLOCK_MONOTONIC, &ts) != 0) {
-        return 0;
-    }
-
-    return ((uint64) ts.tv_sec) * 1000 + ((uint64)ts.tv_nsec) / (1000 * 1000);
-}
-
-uint32 bh_get_tick_sec()
-{
-    return (uint32)(_bh_time_get_boot_millisecond() / 1000);
-}
-
-/*
- * This function returns GMT time milliseconds since from 1970.1.1, AKA UNIX time.
- * @return milliseconds since from 1970.1.1.
- */
-uint64 _bh_time_get_millisecond_from_1970()
-{
-    struct timeval tv;
-    struct timezone tz;
-    gettimeofday(&tv, &tz);
-
-   return tv.tv_sec * 1000 + tv.tv_usec
-           - (tz.tz_dsttime == 0 ? 0 : 60 * 60 * 1000)
-           + tz.tz_minuteswest * 60 * 1000;
-}
-
-size_t _bh_time_strftime(char *s, size_t max, const char *format, int64 time)
-{
-    time_t time_sec = (time_t)(time / 1000);
-    struct timeval tv;
-    struct timezone tz;
-    struct tm *ltp;
-
-    gettimeofday(&tv, &tz);
-    time_sec -= tz.tz_minuteswest * 60;
-
-    ltp = localtime(&time_sec);
-    if (ltp == NULL) {
-        return 0;
-    }
-    return strftime(s, max, format, ltp);
-}
-

core/shared/platform/android/platform_init.c

@@ -3,21 +3,23 @@
  * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
  */
 
-#include "bh_platform.h"
-#include <stdio.h>
-
-#include <android/log.h>
-
-void bh_log_emit(const char *fmt, va_list ap)
+#include "platform_api_vmcore.h"
+#include "platform_api_extension.h"
+int
+bh_platform_init()
 {
-    (void)__android_log_vprint(ANDROID_LOG_INFO, "wasm_runtime::", fmt, ap);
+    return 0;
 }
 
-int bh_fprintf(FILE *stream, const char *fmt, ...)
+void
+bh_platform_destroy()
 {
-    (void)stream;
+}
+
+int os_printf(const char *fmt, ...)
+{
+    int ret;
     va_list ap;
-    int ret = 0;
 
     va_start(ap, fmt);
     ret = __android_log_vprint(ANDROID_LOG_INFO, "wasm_runtime::", fmt, ap);
@@ -26,8 +28,8 @@ int bh_fprintf(FILE *stream, const char *fmt, ...)
     return ret;
 }
 
-int bh_fflush(void *stream)
+int os_vprintf(const char *fmt, va_list ap)
 {
-    (void)stream;
-    return __android_log_print(ANDROID_LOG_INFO, "wasm_runtime::", "%s", "NOT IMPLEMENT");
+    return __android_log_print(ANDROID_LOG_INFO, "wasm_runtime::", fmt, ap);
 }
+

core/shared/platform/android/platform_internal.h

@@ -0,0 +1,58 @@
+/*
+ * Copyright (C) 2019 Intel Corporation.  All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+ */
+
+#ifndef _PLATFORM_INTERNAL_H
+#define _PLATFORM_INTERNAL_H
+
+#include <inttypes.h>
+#include <stdbool.h>
+#include <assert.h>
+#include <time.h>
+#include <sys/time.h>
+#include <string.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <math.h>
+#include <stdarg.h>
+#include <ctype.h>
+#include <pthread.h>
+#include <semaphore.h>
+#include <limits.h>
+#include <fcntl.h>
+#include <unistd.h>
+#include <errno.h>
+#include <sys/socket.h>
+#include <sys/stat.h>
+#include <sys/mman.h>
+#include <netinet/in.h>
+#include <android/log.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifndef BH_PLATFORM_ANDROID
+#define BH_PLATFORM_ANDROID
+#endif
+
+#define _STACK_SIZE_ADJUSTMENT (32 * 1024)
+
+/* Stack size of applet threads's native part.  */
+#define BH_APPLET_PRESERVED_STACK_SIZE (8 * 1024 + _STACK_SIZE_ADJUSTMENT)
+
+/* Default thread priority */
+#define BH_THREAD_DEFAULT_PRIORITY 0
+
+typedef pthread_t korp_tid;
+typedef pthread_mutex_t korp_mutex;
+typedef pthread_cond_t korp_cond;
+typedef pthread_t korp_thread;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* end of _PLATFORM_INTERNAL_H */
+

core/shared/platform/android/shared_platform.cmake

@@ -3,15 +3,16 @@
 
 set (PLATFORM_SHARED_DIR ${CMAKE_CURRENT_LIST_DIR})
 
+add_definitions(-DBH_PLATFORM_ANDROID)
+
 include_directories(${PLATFORM_SHARED_DIR})
 include_directories(${PLATFORM_SHARED_DIR}/../include)
 
+include (${CMAKE_CURRENT_LIST_DIR}/../common/posix/platform_api_posix.cmake)
 
 file (GLOB_RECURSE source_all ${PLATFORM_SHARED_DIR}/*.c)
 
-set (PLATFORM_SHARED_SOURCE ${source_all})
-
-LIST (APPEND RUNTIME_LIB_HEADER_LIST "${PLATFORM_SHARED_DIR}/bh_platform.h")
+set (PLATFORM_SHARED_SOURCE ${source_all} ${PLATFORM_COMMON_POSIX_SOURCE})
 
 file (GLOB header ${PLATFORM_SHARED_DIR}/../include/*.h)
-LIST (APPEND RUNTIME_LIB_HEADER_LIST ${header})
+LIST (APPEND RUNTIME_LIB_HEADER_LIST ${header})

core/shared/platform/common/math/math.c

@@ -28,7 +28,7 @@
  * $FreeBSD$
  */
 
-#include "bh_platform.h"
+#include "platform_common.h"
 
 #define __FDLIBM_STDC__
 
@@ -123,8 +123,8 @@ static union {
 
 #define __HIL(x) *(1+pdouble2pint(&x))
 #define __LOL(x) *(pdouble2pint(&x))
-#define __HIB(x) *(int*)&x
-#define __LOB(x) *(1+(int*)&x)
+#define __HIB(x) *(pdouble2pint(&x))
+#define __LOB(x) *(1+pdouble2pint(&x))
 
 /* Get two 32 bit ints from a double.  */
 

core/shared/platform/common/math/platform_api_math.cmake

@@ -0,0 +1,8 @@
+# Copyright (C) 2019 Intel Corporation.  All rights reserved.
+# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+ 
+set (PLATFORM_COMMON_MATH_DIR ${CMAKE_CURRENT_LIST_DIR})
+
+file (GLOB_RECURSE source_all ${PLATFORM_COMMON_MATH_DIR}/*.c)
+
+set (PLATFORM_COMMON_MATH_SOURCE ${source_all} )

core/shared/platform/common/posix/platform_api_posix.cmake

@@ -0,0 +1,8 @@
+# Copyright (C) 2019 Intel Corporation.  All rights reserved.
+# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+ 
+set (PLATFORM_COMMON_POSIX_DIR ${CMAKE_CURRENT_LIST_DIR})
+
+file (GLOB_RECURSE source_all ${PLATFORM_COMMON_POSIX_DIR}/*.c)
+
+set (PLATFORM_COMMON_POSIX_SOURCE ${source_all} )

core/shared/platform/common/posix/posix_malloc.c

@@ -0,0 +1,27 @@
+/*
+ * Copyright (C) 2019 Intel Corporation.  All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+ */
+
+#include "platform_api_vmcore.h"
+
+void *
+os_malloc(unsigned size)
+{
+    return malloc(size);
+}
+
+void *
+os_realloc(void *ptr, unsigned size)
+{
+    return realloc(ptr, size);
+}
+
+void
+os_free(void *ptr)
+{
+    free(ptr);
+}
+
+
+

core/shared/platform/common/posix/posix_memmap.c

@@ -3,88 +3,10 @@
  * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
  */
 
-#include "bh_platform.h"
-#include "bh_common.h"
-#include "bh_assert.h"
-
-#include <sys/stat.h>
-#include <fcntl.h>
-#include <unistd.h>
-#include <sys/mman.h>
-
-int
-bh_platform_init()
-{
-    return 0;
-}
+#include "platform_api_vmcore.h"
 
 void *
-os_malloc(unsigned size)
-{
-    return malloc(size);
-}
-
-void *
-os_realloc(void *ptr, unsigned size)
-{
-    return realloc(ptr, size);
-}
-
-void
-os_free(void *ptr)
-{
-    free(ptr);
-}
-
-char*
-bh_read_file_to_buffer(const char *filename, uint32 *ret_size)
-{
-    char *buffer;
-    int file;
-    uint32 file_size, read_size;
-    struct stat stat_buf;
-
-    if (!filename || !ret_size) {
-        printf("Read file to buffer failed: invalid filename or ret size.\n");
-        return NULL;
-    }
-
-    if ((file = open(filename, O_RDONLY, 0)) == -1) {
-        printf("Read file to buffer failed: open file %s failed.\n",
-               filename);
-        return NULL;
-    }
-
-    if (fstat(file, &stat_buf) != 0) {
-        printf("Read file to buffer failed: fstat file %s failed.\n",
-               filename);
-        close(file);
-        return NULL;
-    }
-
-    file_size = (uint32)stat_buf.st_size;
-
-    if (!(buffer = BH_MALLOC(file_size))) {
-        printf("Read file to buffer failed: alloc memory failed.\n");
-        close(file);
-        return NULL;
-    }
-
-    read_size = (uint32)read(file, buffer, file_size);
-    close(file);
-
-    if (read_size < file_size) {
-        printf("Read file to buffer failed: read file content failed.\n");
-        BH_FREE(buffer);
-        return NULL;
-    }
-
-    *ret_size = file_size;
-    return buffer;
-}
-
-void *
-bh_mmap(void *hint, uint32 size, int prot, int flags)
+os_mmap(void *hint, uint32 size, int prot, int flags)
 {
     int map_prot = PROT_NONE;
     int map_flags = MAP_ANONYMOUS | MAP_PRIVATE;
@@ -110,8 +32,10 @@ bh_mmap(void *hint, uint32 size, int prot, int flags)
         map_prot |= PROT_EXEC;
 
 #if defined(BUILD_TARGET_X86_64) || defined(BUILD_TARGET_AMD_64)
+#ifndef __APPLE__
     if (flags & MMAP_MAP_32BIT)
         map_flags |= MAP_32BIT;
+#endif
 #endif
 
     if (flags & MMAP_MAP_FIXED)
@@ -156,14 +80,14 @@ bh_mmap(void *hint, uint32 size, int prot, int flags)
 }
 
 void
-bh_munmap(void *addr, uint32 size)
+os_munmap(void *addr, uint32 size)
 {
     if (addr)
         munmap(addr, size);
 }
 
 int
-bh_mprotect(void *addr, uint32 size, int prot)
+os_mprotect(void *addr, uint32 size, int prot)
 {
     int map_prot = PROT_NONE;
 
@@ -182,3 +106,7 @@ bh_mprotect(void *addr, uint32 size, int prot)
     return mprotect(addr, size, map_prot);
 }
 
+void
+os_dcache_flush(void)
+{
+}

core/shared/platform/common/posix/posix_thread.c

@@ -0,0 +1,220 @@
+/*
+ * Copyright (C) 2019 Intel Corporation.  All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+ */
+
+#include "platform_api_vmcore.h"
+#include "platform_api_extension.h"
+
+typedef struct {
+    thread_start_routine_t start;
+    void* stack;
+    uint32 stack_size;
+    void* arg;
+} thread_wrapper_arg;
+
+static void *os_thread_wrapper(void *arg)
+{
+    thread_wrapper_arg * targ = arg;
+    printf("THREAD CREATE %p\n", &targ);
+    targ->stack = (void *)((uintptr_t)(&arg) & (uintptr_t)~0xfff);
+    targ->start(targ->arg);
+    BH_FREE(targ);
+    return NULL;
+}
+
+int os_thread_create_with_prio(korp_tid *tid, thread_start_routine_t start,
+                               void *arg, unsigned int stack_size, int prio)
+{
+    pthread_attr_t tattr;
+    thread_wrapper_arg *targ;
+
+    assert(stack_size > 0);
+    assert(tid);
+    assert(start);
+
+    pthread_attr_init(&tattr);
+    pthread_attr_setdetachstate(&tattr, PTHREAD_CREATE_JOINABLE);
+    if (pthread_attr_setstacksize(&tattr, stack_size) != 0) {
+        printf("Invalid thread stack size %u. Min stack size on Linux = %u",
+               stack_size, PTHREAD_STACK_MIN);
+        pthread_attr_destroy(&tattr);
+        return BHT_ERROR;
+    }
+
+    targ = (thread_wrapper_arg*) BH_MALLOC(sizeof(*targ));
+    if (!targ) {
+        pthread_attr_destroy(&tattr);
+        return BHT_ERROR;
+    }
+
+    targ->start = start;
+    targ->arg = arg;
+    targ->stack_size = stack_size;
+
+    if (pthread_create(tid, &tattr, os_thread_wrapper, targ) != 0) {
+        pthread_attr_destroy(&tattr);
+        BH_FREE(targ);
+        return BHT_ERROR;
+    }
+
+    pthread_attr_destroy(&tattr);
+    return BHT_OK;
+}
+
+int os_thread_create(korp_tid *tid, thread_start_routine_t start, void *arg,
+                     unsigned int stack_size)
+{
+    return os_thread_create_with_prio(tid, start, arg, stack_size,
+                                      BH_THREAD_DEFAULT_PRIORITY);
+}
+
+korp_tid os_self_thread()
+{
+    return (korp_tid) pthread_self();
+}
+
+int os_mutex_init(korp_mutex *mutex)
+{
+    return pthread_mutex_init(mutex, NULL) == 0 ? BHT_OK : BHT_ERROR;
+}
+
+int os_recursive_mutex_init(korp_mutex *mutex)
+{
+    int ret;
+
+    pthread_mutexattr_t mattr;
+
+    assert(mutex);
+    ret = pthread_mutexattr_init(&mattr);
+    if (ret)
+        return BHT_ERROR;
+
+    pthread_mutexattr_settype(&mattr, PTHREAD_MUTEX_RECURSIVE);
+    ret = pthread_mutex_init(mutex, &mattr);
+    pthread_mutexattr_destroy(&mattr);
+
+    return ret == 0 ? BHT_OK : BHT_ERROR;
+}
+
+int os_mutex_destroy(korp_mutex *mutex)
+{
+    int ret;
+
+    assert(mutex);
+    ret = pthread_mutex_destroy(mutex);
+
+    return ret == 0 ? BHT_OK : BHT_ERROR;
+}
+
+/* Returned error (EINVAL, EAGAIN and EDEADLK) from
+ locking the mutex indicates some logic error present in
+ the program somewhere.
+ Don't try to recover error for an existing unknown error.*/
+void os_mutex_lock(korp_mutex *mutex)
+{
+    int ret;
+
+    assert(mutex);
+    ret = pthread_mutex_lock(mutex);
+    if (0 != ret) {
+        printf("vm mutex lock failed (ret=%d)!\n", ret);
+        exit(-1);
+    }
+}
+
+/* Returned error (EINVAL, EAGAIN and EPERM) from
+ unlocking the mutex indicates some logic error present
+ in the program somewhere.
+ Don't try to recover error for an existing unknown error.*/
+void os_mutex_unlock(korp_mutex *mutex)
+{
+    int ret;
+
+    assert(mutex);
+    ret = pthread_mutex_unlock(mutex);
+    if (0 != ret) {
+        printf("vm mutex unlock failed (ret=%d)!\n", ret);
+        exit(-1);
+    }
+}
+
+int os_cond_init(korp_cond *cond)
+{
+    assert(cond);
+
+    if (pthread_cond_init(cond, NULL) != BHT_OK)
+        return BHT_ERROR;
+
+    return BHT_OK;
+}
+
+int os_cond_destroy(korp_cond *cond)
+{
+    assert(cond);
+
+    if (pthread_cond_destroy(cond) != BHT_OK)
+        return BHT_ERROR;
+
+    return BHT_OK;
+}
+
+int os_cond_wait(korp_cond *cond, korp_mutex *mutex)
+{
+    assert(cond);
+    assert(mutex);
+
+    if (pthread_cond_wait(cond, mutex) != BHT_OK)
+        return BHT_ERROR;
+
+    return BHT_OK;
+}
+
+static void msec_nsec_to_abstime(struct timespec *ts, int usec)
+{
+    struct timeval tv;
+
+    gettimeofday(&tv, NULL);
+
+    ts->tv_sec = (long int)(tv.tv_sec + usec / 1000000);
+    ts->tv_nsec = (long int)(tv.tv_usec * 1000 + (usec % 1000000) * 1000);
+
+    if (ts->tv_nsec >= 1000000000L) {
+        ts->tv_sec++;
+        ts->tv_nsec -= 1000000000L;
+    }
+}
+
+int os_cond_reltimedwait(korp_cond *cond, korp_mutex *mutex, int useconds)
+{
+    int ret;
+    struct timespec abstime;
+
+    if (useconds == (int)BHT_WAIT_FOREVER)
+        ret = pthread_cond_wait(cond, mutex);
+    else {
+        msec_nsec_to_abstime(&abstime, useconds);
+        ret = pthread_cond_timedwait(cond, mutex, &abstime);
+    }
+
+    if (ret != BHT_OK && ret != ETIMEDOUT)
+        return BHT_ERROR;
+
+    return BHT_OK;
+}
+
+int os_cond_signal(korp_cond *cond)
+{
+    assert(cond);
+
+    if (pthread_cond_signal(cond) != BHT_OK)
+        return BHT_ERROR;
+
+    return BHT_OK;
+}
+
+int os_thread_join(korp_tid thread, void **value_ptr)
+{
+    return pthread_join(thread, value_ptr);
+}
+

core/shared/platform/common/posix/posix_time.c

@@ -0,0 +1,18 @@
+/*
+ * Copyright (C) 2019 Intel Corporation.  All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+ */
+
+#include "platform_api_vmcore.h"
+
+uint64
+os_time_get_boot_microsecond()
+{
+    struct timespec ts;
+    if (clock_gettime(CLOCK_MONOTONIC, &ts) != 0) {
+        return 0;
+    }
+
+    return ((uint64) ts.tv_sec) * 1000 * 1000 + ((uint64)ts.tv_nsec) / 1000;
+}
+

core/shared/platform/darwin/bh_assert.c

@@ -1,58 +0,0 @@
-/*
- * Copyright (C) 2019 Intel Corporation.  All rights reserved.
- * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
- */
-
-#include "bh_platform.h"
-#include "bh_assert.h"
-#include <stdarg.h>
-#include <stdio.h>
-#include <stdlib.h>
-
-#ifdef BH_TEST
-#include <setjmp.h>
-#endif
-
-#ifdef BH_TEST
-/* for exception throwing */
-jmp_buf bh_test_jb;
-#endif
-
-void bh_assert_internal(int v, const char *file_name, int line_number,
-        const char *expr_string)
-{
-    if (v)
-        return;
-
-    if (!file_name)
-        file_name = "NULL FILENAME";
-    if (!expr_string)
-        expr_string = "NULL EXPR_STRING";
-
-    printf("\nASSERTION FAILED: %s, at FILE=%s, LINE=%d\n", expr_string,
-            file_name, line_number);
-
-#ifdef BH_TEST
-    longjmp(bh_test_jb, 1);
-#endif
-
-    abort();
-}
-
-void bh_debug_internal(const char *file_name, int line_number, const char *fmt,
-        ...)
-{
-#ifndef JEFF_TEST_VERIFIER
-    va_list args;
-
-    va_start(args, fmt);
-    bh_assert(file_name);
-
-    printf("\nDebug info FILE=%s, LINE=%d: ", file_name, line_number);
-    vprintf(fmt, args);
-
-    va_end(args);
-    printf("\n");
-#endif
-}
-

core/shared/platform/darwin/bh_platform.h

@@ -1,123 +0,0 @@
-/*
- * Copyright (C) 2019 Intel Corporation.  All rights reserved.
- * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
- */
-
-#ifndef _BH_PLATFORM_H
-#define _BH_PLATFORM_H
-
-#include "bh_config.h"
-#include "bh_types.h"
-#include <inttypes.h>
-#include <stdbool.h>
-#include <assert.h>
-#include <time.h>
-#include <string.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <math.h>
-#include <stdarg.h>
-#include <ctype.h>
-#include <pthread.h>
-#include <limits.h>
-#include <fcntl.h>
-#include <semaphore.h>
-#include <errno.h>
-#include <sys/socket.h>
-#include <netinet/in.h>
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-typedef uint64_t uint64;
-typedef int64_t int64;
-
-#ifndef BH_PLATFORM_DARWIN
-#define BH_PLATFORM_DARWIN
-#endif
-
-#define _STACK_SIZE_ADJUSTMENT (32 * 1024)
-
-/* Stack size of applet threads's native part.  */
-#define BH_APPLET_PRESERVED_STACK_SIZE      (8 * 1024 + _STACK_SIZE_ADJUSTMENT)
-
-/* Default thread priority */
-#define BH_THREAD_DEFAULT_PRIORITY 0
-
-#define BH_ROUTINE_MODIFIER
-
-#define BHT_TIMEDOUT ETIMEDOUT
-
-#define INVALID_THREAD_ID 0xFFffFFff
-
-typedef pthread_t korp_tid;
-typedef pthread_mutex_t korp_mutex;
-typedef sem_t korp_sem;
-typedef pthread_cond_t korp_cond;
-typedef pthread_t korp_thread;
-typedef void* (*thread_start_routine_t)(void*);
-
-void *os_malloc(unsigned size);
-void *os_realloc(void *ptr, unsigned size);
-void os_free(void *ptr);
-
-#define bh_printf printf
-
-/* int snprintf(char *buffer, size_t count, const char *format, ...); */
-double fmod(double x, double y);
-float fmodf(float x, float y);
-double sqrt(double x);
-
-#define BH_WAIT_FOREVER 0xFFFFFFFF
-
-#ifndef NULL
-#  define NULL ((void*) 0)
-#endif
-
-/**
- * Return the offset of the given field in the given type.
- *
- * @param Type the type containing the filed
- * @param field the field in the type
- *
- * @return the offset of field in Type
- */
-#ifndef offsetof
-#define offsetof(Type, field) ((size_t)(&((Type *)0)->field))
-#endif
-
-#define bh_assert assert
-
-char *bh_read_file_to_buffer(const char *filename, uint32 *ret_size);
-
-int bh_platform_init();
-
-/* MMAP mode */
-enum {
-    MMAP_PROT_NONE = 0,
-    MMAP_PROT_READ = 1,
-    MMAP_PROT_WRITE = 2,
-    MMAP_PROT_EXEC = 4
-};
-
-/* MMAP flags */
-enum {
-    MMAP_MAP_NONE = 0,
-    /* Put the mapping into 0 to 2 G, supported only on x86_64 */
-    MMAP_MAP_32BIT = 1,
-    /* Don't interpret addr as a hint: place the mapping at exactly
-       that address. */
-    MMAP_MAP_FIXED = 2
-};
-
-void *bh_mmap(void *hint, unsigned int size, int prot, int flags);
-void bh_munmap(void *addr, uint32 size);
-int bh_mprotect(void *addr, uint32 size, int prot);
-#define bh_dcache_flush() (void)0
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif

core/shared/platform/darwin/bh_platform_log.c

@@ -1,30 +0,0 @@
-/*
- * Copyright (C) 2019 Intel Corporation.  All rights reserved.
- * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
- */
-
-#include "bh_platform.h"
-#include <stdio.h>
-
-void bh_log_emit(const char *fmt, va_list ap)
-{
-    vprintf(fmt, ap);
-    fflush(stdout);
-}
-
-int bh_fprintf(FILE *stream, const char *fmt, ...)
-{
-    va_list ap;
-    int ret;
-
-    va_start(ap, fmt);
-    ret = vfprintf(stream ? stream : stdout, fmt, ap);
-    va_end(ap);
-
-    return ret;
-}
-
-int bh_fflush(void *stream)
-{
-    return fflush(stream ? stream : stdout);
-}

core/shared/platform/darwin/bh_thread.c

@@ -1,393 +0,0 @@
-/*
- * Copyright (C) 2019 Intel Corporation.  All rights reserved.
- * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
- */
-
-#include "bh_thread.h"
-#include "bh_assert.h"
-#include "bh_log.h"
-#include <stdio.h>
-#include <stdlib.h>
-#include <sys/time.h>
-
-static bool is_thread_sys_inited = false;
-
-static korp_mutex thread_list_lock;
-static pthread_key_t thread_local_storage_key[BH_MAX_TLS_NUM];
-
-int _vm_thread_sys_init()
-{
-    unsigned i, j;
-    int ret;
-
-    if (is_thread_sys_inited)
-        return 0;
-
-    for (i = 0; i < BH_MAX_TLS_NUM; i++) {
-        ret = pthread_key_create(&thread_local_storage_key[i], NULL);
-        if (ret)
-            goto fail;
-    }
-
-    ret = vm_mutex_init(&thread_list_lock);
-    if (ret)
-        goto fail;
-
-    is_thread_sys_inited = true;
-    return 0;
-
-    fail: for (j = 0; j < i; j++)
-        pthread_key_delete(thread_local_storage_key[j]);
-    return -1;
-}
-
-void vm_thread_sys_destroy(void)
-{
-    if (is_thread_sys_inited) {
-        unsigned i;
-        for (i = 0; i < BH_MAX_TLS_NUM; i++)
-            pthread_key_delete(thread_local_storage_key[i]);
-        vm_mutex_destroy(&thread_list_lock);
-        is_thread_sys_inited = false;
-    }
-}
-
-typedef struct {
-    thread_start_routine_t start;
-    void* stack;
-    uint32 stack_size;
-    void* arg;
-} thread_wrapper_arg;
-
-static void *vm_thread_wrapper(void *arg)
-{
-    thread_wrapper_arg * targ = arg;
-    LOG_VERBOSE("THREAD CREATE 0x%08x\n", &targ);
-    targ->stack = (void *)((uintptr_t)(&arg) & (uintptr_t)~0xfff);
-    _vm_tls_put(1, targ);
-    targ->start(targ->arg);
-    BH_FREE(targ);
-    _vm_tls_put(1, NULL);
-    return NULL;
-}
-
-int _vm_thread_create_with_prio(korp_tid *tid, thread_start_routine_t start,
-                                void *arg, unsigned int stack_size, int prio)
-{
-    pthread_attr_t tattr;
-    thread_wrapper_arg *targ;
-
-    bh_assert(stack_size > 0);
-    bh_assert(tid);
-    bh_assert(start);
-
-    *tid = INVALID_THREAD_ID;
-
-    pthread_attr_init(&tattr);
-    pthread_attr_setdetachstate(&tattr, PTHREAD_CREATE_JOINABLE);
-    if (pthread_attr_setstacksize(&tattr, stack_size) != 0) {
-        bh_debug("Invalid thread stack size %u. Min stack size on Linux = %u",
-                stack_size, PTHREAD_STACK_MIN);
-        pthread_attr_destroy(&tattr);
-        return BHT_ERROR;
-    }
-
-    targ = (thread_wrapper_arg*) BH_MALLOC(sizeof(*targ));
-    if (!targ) {
-        pthread_attr_destroy(&tattr);
-        return BHT_ERROR;
-    }
-
-    targ->start = start;
-    targ->arg = arg;
-    targ->stack_size = stack_size;
-
-    if (pthread_create(tid, &tattr, vm_thread_wrapper, targ) != 0) {
-        pthread_attr_destroy(&tattr);
-        BH_FREE(targ);
-        return BHT_ERROR;
-    }
-
-    pthread_attr_destroy(&tattr);
-    return BHT_OK;
-}
-
-int _vm_thread_create(korp_tid *tid, thread_start_routine_t start, void *arg,
-                      unsigned int stack_size)
-{
-    return _vm_thread_create_with_prio(tid, start, arg, stack_size,
-                                       BH_THREAD_DEFAULT_PRIORITY);
-}
-
-korp_tid _vm_self_thread()
-{
-    return (korp_tid) pthread_self();
-}
-
-void vm_thread_exit(void * code)
-{
-    BH_FREE(_vm_tls_get(1));
-    _vm_tls_put(1, NULL);
-    pthread_exit(code);
-}
-
-void *_vm_tls_get(unsigned idx)
-{
-    bh_assert(idx < BH_MAX_TLS_NUM);
-    return pthread_getspecific(thread_local_storage_key[idx]);
-}
-
-int _vm_tls_put(unsigned idx, void * tls)
-{
-    bh_assert(idx < BH_MAX_TLS_NUM);
-    pthread_setspecific(thread_local_storage_key[idx], tls);
-    return BHT_OK;
-}
-
-int _vm_mutex_init(korp_mutex *mutex)
-{
-    return pthread_mutex_init(mutex, NULL) == 0 ? BHT_OK : BHT_ERROR;
-}
-
-int _vm_recursive_mutex_init(korp_mutex *mutex)
-{
-    int ret;
-
-    pthread_mutexattr_t mattr;
-
-    bh_assert(mutex);
-    ret = pthread_mutexattr_init(&mattr);
-    if (ret)
-        return BHT_ERROR;
-
-    pthread_mutexattr_settype(&mattr, PTHREAD_MUTEX_RECURSIVE);
-    ret = pthread_mutex_init(mutex, &mattr);
-    pthread_mutexattr_destroy(&mattr);
-
-    return ret == 0 ? BHT_OK : BHT_ERROR;
-}
-
-int _vm_mutex_destroy(korp_mutex *mutex)
-{
-    int ret;
-
-    bh_assert(mutex);
-    ret = pthread_mutex_destroy(mutex);
-
-    return ret == 0 ? BHT_OK : BHT_ERROR;
-}
-
-/* Returned error (EINVAL, EAGAIN and EDEADLK) from
- locking the mutex indicates some logic error present in
- the program somewhere.
- Don't try to recover error for an existing unknown error.*/
-void vm_mutex_lock(korp_mutex *mutex)
-{
-    int ret;
-
-    bh_assert(mutex);
-    ret = pthread_mutex_lock(mutex);
-    if (0 != ret) {
-        printf("vm mutex lock failed (ret=%d)!\n", ret);
-        exit(-1);
-    }
-}
-
-int vm_mutex_trylock(korp_mutex *mutex)
-{
-    int ret;
-
-    bh_assert(mutex);
-    ret = pthread_mutex_trylock(mutex);
-
-    return ret == 0 ? BHT_OK : BHT_ERROR;
-}
-
-/* Returned error (EINVAL, EAGAIN and EPERM) from
- unlocking the mutex indicates some logic error present
- in the program somewhere.
- Don't try to recover error for an existing unknown error.*/
-void vm_mutex_unlock(korp_mutex *mutex)
-{
-    int ret;
-
-    bh_assert(mutex);
-    ret = pthread_mutex_unlock(mutex);
-    if (0 != ret) {
-        printf("vm mutex unlock failed (ret=%d)!\n", ret);
-        exit(-1);
-    }
-}
-
-int _vm_sem_init(korp_sem* sem, unsigned int c)
-{
-    int ret;
-
-    bh_assert(sem);
-    ret = sem_init(sem, 0, c);
-
-    return ret == 0 ? BHT_OK : BHT_ERROR;
-}
-
-int _vm_sem_destroy(korp_sem *sem)
-{
-    int ret;
-
-    bh_assert(sem);
-    ret = sem_destroy(sem);
-
-    return ret == 0 ? BHT_OK : BHT_ERROR;
-}
-
-int _vm_sem_wait(korp_sem *sem)
-{
-    int ret;
-
-    bh_assert(sem);
-
-    ret = sem_wait(sem);
-
-    return ret == 0 ? BHT_OK : BHT_ERROR;
-}
-
-/*int _vm_sem_reltimedwait(korp_sem *sem, int mills)
-{
-    int ret = BHT_OK;
-
-    struct timespec timeout;
-    const int mills_per_sec = 1000;
-    const int mills_to_nsec = 1E6;
-
-    bh_assert(sem);
-
-    if (mills == (int)BHT_WAIT_FOREVER) {
-        ret = sem_wait(sem);
-    } else {
-
-        timeout.tv_sec = mills / mills_per_sec;
-        timeout.tv_nsec = (mills % mills_per_sec) * mills_to_nsec;
-        timeout.tv_sec += time(NULL);
-
-        ret = sem_timedwait(sem, &timeout);
-    }
-
-    if (ret != BHT_OK) {
-        if (errno == BHT_TIMEDOUT) {
-            ret = BHT_TIMEDOUT;
-            errno = 0;
-        } else {
-            bh_debug("Faliure happens when timed wait is called");
-            bh_assert(0);
-        }
-    }
-
-    return ret;
-}
-*/
-
-int _vm_sem_post(korp_sem *sem)
-{
-    bh_assert(sem);
-
-    return sem_post(sem) == 0 ? BHT_OK : BHT_ERROR;
-}
-
-int _vm_cond_init(korp_cond *cond)
-{
-    bh_assert(cond);
-
-    if (pthread_cond_init(cond, NULL) != BHT_OK)
-        return BHT_ERROR;
-
-    return BHT_OK;
-}
-
-int _vm_cond_destroy(korp_cond *cond)
-{
-    bh_assert(cond);
-
-    if (pthread_cond_destroy(cond) != BHT_OK)
-        return BHT_ERROR;
-
-    return BHT_OK;
-}
-
-int _vm_cond_wait(korp_cond *cond, korp_mutex *mutex)
-{
-    bh_assert(cond);
-    bh_assert(mutex);
-
-    if (pthread_cond_wait(cond, mutex) != BHT_OK)
-        return BHT_ERROR;
-
-    return BHT_OK;
-}
-
-static void msec_nsec_to_abstime(struct timespec *ts, int64 msec, int32 nsec)
-{
-    struct timeval tv;
-
-    gettimeofday(&tv, NULL);
-
-    ts->tv_sec = (long int)(tv.tv_sec + msec / 1000);
-    ts->tv_nsec = (long int)(tv.tv_usec * 1000 + (msec % 1000) * 1000000 + nsec);
-
-    if (ts->tv_nsec >= 1000000000L) {
-        ts->tv_sec++;
-        ts->tv_nsec -= 1000000000L;
-    }
-}
-
-int _vm_cond_reltimedwait(korp_cond *cond, korp_mutex *mutex, int mills)
-{
-    int ret;
-    struct timespec abstime;
-
-    if (mills == (int)BHT_WAIT_FOREVER)
-        ret = pthread_cond_wait(cond, mutex);
-    else {
-        msec_nsec_to_abstime(&abstime, mills, 0);
-        ret = pthread_cond_timedwait(cond, mutex, &abstime);
-    }
-
-    if (ret != BHT_OK && ret != BHT_TIMEDOUT)
-        return BHT_ERROR;
-
-    return BHT_OK;
-}
-
-int _vm_cond_signal(korp_cond *cond)
-{
-    bh_assert(cond);
-
-    if (pthread_cond_signal(cond) != BHT_OK)
-        return BHT_ERROR;
-
-    return BHT_OK;
-}
-
-int _vm_cond_broadcast(korp_cond *cond)
-{
-    bh_assert(cond);
-
-    if (pthread_cond_broadcast(cond) != BHT_OK)
-        return BHT_ERROR;
-
-    return BHT_OK;
-}
-
-int _vm_thread_cancel(korp_tid thread)
-{
-    return pthread_cancel(thread);
-}
-
-int _vm_thread_join(korp_tid thread, void **value_ptr, int mills)
-{
-    return pthread_join(thread, value_ptr);
-}
-
-int _vm_thread_detach(korp_tid thread)
-{
-    return pthread_detach(thread);
-}
-

core/shared/platform/darwin/bh_time.c

@@ -1,70 +0,0 @@
-/*
- * Copyright (C) 2019 Intel Corporation.  All rights reserved.
- * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
- */
-
-#include "bh_time.h"
-
-#include <unistd.h>
-#include <stdio.h>
-#include <sys/timeb.h>
-#include <time.h>
-
-/*
- * This function returns milliseconds per tick.
- * @return milliseconds per tick.
- */
-uint64 _bh_time_get_tick_millisecond()
-{
-    return (uint64)sysconf(_SC_CLK_TCK);
-}
-
-/*
- * This function returns milliseconds after boot.
- * @return milliseconds after boot.
- */
-uint64 _bh_time_get_boot_millisecond()
-{
-    struct timespec ts;
-    if (clock_gettime(CLOCK_MONOTONIC, &ts) != 0) {
-        return 0;
-    }
-
-    return ((uint64) ts.tv_sec) * 1000 + ((uint64)ts.tv_nsec) / (1000 * 1000);
-}
-
-uint32 bh_get_tick_sec()
-{
-    return (uint32)(_bh_time_get_boot_millisecond() / 1000);
-}
-
-/*
- * This function returns GMT time milliseconds since from 1970.1.1, AKA UNIX time.
- * @return milliseconds since from 1970.1.1.
- */
-uint64 _bh_time_get_millisecond_from_1970()
-{
-    struct timeb tp;
-    ftime(&tp);
-
-    return ((uint64) tp.time) * 1000 + tp.millitm
-            - (tp.dstflag == 0 ? 0 : 60 * 60 * 1000)
-            + ((uint64)tp.timezone) * 60 * 1000;
-}
-
-size_t _bh_time_strftime(char *s, size_t max, const char *format, int64 time)
-{
-    time_t time_sec = (time_t)(time / 1000);
-    struct timeb tp;
-    struct tm *ltp;
-
-    ftime(&tp);
-    time_sec -= tp.timezone * 60;
-
-    ltp = localtime(&time_sec);
-    if (ltp == NULL) {
-        return 0;
-    }
-    return strftime(s, max, format, ltp);
-}
-

core/shared/platform/darwin/platform_init.c

@@ -3,15 +3,16 @@
  * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
  */
 
-#include "bh_platform.h"
-#include <stdio.h>
+#include "platform_api_vmcore.h"
 
-void bh_log_emit(const char *fmt, va_list ap)
-{
-    bh_vprintf_sgx(fmt, ap);
-}
-
-int bh_fflush(void *stream)
+int
+bh_platform_init()
 {
     return 0;
 }
+
+void
+bh_platform_destroy()
+{
+}
+

core/shared/platform/darwin/platform_internal.h

@@ -0,0 +1,61 @@
+/*
+ * Copyright (C) 2019 Intel Corporation.  All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+ */
+
+#ifndef _PLATFORM_INTERNAL_H
+#define _PLATFORM_INTERNAL_H
+
+#include <inttypes.h>
+#include <stdbool.h>
+#include <assert.h>
+#include <time.h>
+#include <sys/time.h>
+#include <sys/timeb.h>
+#include <string.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <math.h>
+#include <stdarg.h>
+#include <ctype.h>
+#include <pthread.h>
+#include <semaphore.h>
+#include <limits.h>
+#include <fcntl.h>
+#include <unistd.h>
+#include <errno.h>
+#include <sys/socket.h>
+#include <sys/stat.h>
+#include <sys/mman.h>
+#include <netinet/in.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifndef BH_PLATFORM_DARWIN
+#define BH_PLATFORM_DARWIN
+#endif
+
+#define _STACK_SIZE_ADJUSTMENT (32 * 1024)
+
+/* Stack size of applet threads's native part.  */
+#define BH_APPLET_PRESERVED_STACK_SIZE (8 * 1024 + _STACK_SIZE_ADJUSTMENT)
+
+/* Default thread priority */
+#define BH_THREAD_DEFAULT_PRIORITY 0
+
+typedef pthread_t korp_tid;
+typedef pthread_mutex_t korp_mutex;
+typedef pthread_cond_t korp_cond;
+typedef pthread_t korp_thread;
+
+#define os_printf printf
+#define os_vprintf vprintf
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* end of _PLATFORM_INTERNAL_H */
+

core/shared/platform/darwin/shared_platform.cmake

@@ -3,11 +3,16 @@
 
 set (PLATFORM_SHARED_DIR ${CMAKE_CURRENT_LIST_DIR})
 
+add_definitions(-DBH_PLATFORM_DARWIN)
+
 include_directories(${PLATFORM_SHARED_DIR})
 include_directories(${PLATFORM_SHARED_DIR}/../include)
 
+include (${CMAKE_CURRENT_LIST_DIR}/../common/posix/platform_api_posix.cmake)
 
 file (GLOB_RECURSE source_all ${PLATFORM_SHARED_DIR}/*.c)
 
-set (PLATFORM_SHARED_SOURCE ${source_all})
+set (PLATFORM_SHARED_SOURCE ${source_all} ${PLATFORM_COMMON_POSIX_SOURCE})
 
+file (GLOB header ${PLATFORM_SHARED_DIR}/../include/*.h)
+LIST (APPEND RUNTIME_LIB_HEADER_LIST ${header})

core/shared/platform/include/bh_assert.h

@@ -1,62 +0,0 @@
-/*
- * Copyright (C) 2019 Intel Corporation.  All rights reserved.
- * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
- */
-
-#ifndef _BH_ASSERT_H
-#define _BH_ASSERT_H
-
-#include "bh_config.h"
-#include "bh_platform.h"
-
-#ifdef BH_TEST
-#    ifndef BH_DEBUG
-#        error "BH_TEST should be defined under BH_DEBUG"
-#    endif
-#endif
-
-#ifdef BH_TEST
-#    if defined(WIN32) || defined(__linux__)
-#    else
-#        error "Test case can not run on the current platform"
-#    endif
-#endif
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#ifdef BH_DEBUG
-
-void bh_assert_internal(int v, const char *file_name, int line_number,
-                        const char *expr_string);
-#define bh_assert(expr) bh_assert_internal((int)(expr), __FILE__, __LINE__, #expr)
-
-void bh_debug_internal(const char *file_name, int line_number,
-                       const char *fmt, ...);
-#if defined(WIN32)
-  #define bh_debug(fmt, ...) bh_debug_internal(__FILE__, __LINE__, fmt, __VA_ARGS__)
-#elif defined(__linux__)
-  #define bh_debug bh_debug_internal(__FILE__, __LINE__, "");printf
-#else
-  #error "Unsupported platform"
-#endif
-
-#else /* else of BH_DEBUG */
-
-#define bh_debug if(0)printf
-
-#endif /* end of BH_DEBUG */
-
-#ifdef BH_TEST
-  #define BH_STATIC
-#else
-  #define BH_STATIC static
-#endif /* end of BH_TEST */
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif
-

core/shared/platform/include/bh_config.h

@@ -1,53 +0,0 @@
-/*
- * Copyright (C) 2019 Intel Corporation.  All rights reserved.
- * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
- */
-
-/**
- * @file   bh_config.h
- * @date   Tue Sep 13 14:53:17 2011
- *
- * @brief Configurations for different platforms and targets.  Make
- * sure all source files in Beihai project include this header file
- * directly or indirectly.
- */
-
-#ifndef BH_CONFIG
-
-#include "config.h"
-
-#define BH_KB (1024)
-#define BH_MB ((BH_KB)*1024)
-#define BH_GB ((BH_MB)*1024)
-
-#ifndef BH_MALLOC
-#define BH_MALLOC os_malloc
-#endif
-
-#ifndef BH_FREE
-#define BH_FREE os_free
-#endif
-
-#ifndef WA_MALLOC
-#include <stdlib.h>
-#define WA_MALLOC malloc
-#endif
-
-#ifndef WA_FREE
-#include <stdlib.h>
-#define WA_FREE free
-#endif
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-void *wasm_runtime_malloc(unsigned int size);
-void wasm_runtime_free(void *ptr);
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* end of BH_CONFIG */
-

core/shared/platform/include/bh_platform_log.h

@@ -1,25 +0,0 @@
-/*
- * Copyright (C) 2019 Intel Corporation.  All rights reserved.
- * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
- */
-
-#ifndef BH_PLATFORM_LOG
-#define BH_PLATFORM_LOG
-
-#include "bh_platform.h"
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-void bh_log_emit(const char *fmt, va_list ap);
-
-int bh_fprintf(void *stream, const char *fmt, ...);
-
-int bh_fflush(void *stream);
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif

core/shared/platform/include/bh_thread.h

@@ -1,398 +0,0 @@
-/*
- * Copyright (C) 2019 Intel Corporation.  All rights reserved.
- * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
- */
-
-#ifndef _BH_THREAD_H
-#define _BH_THREAD_H
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#include "bh_config.h"
-#include "bh_platform.h"
-
-#define BH_MAX_THREAD 32
-#define BH_MAX_TLS_NUM 2
-
-#define BHT_ERROR (-1)
-#define BHT_TIMED_OUT (1)
-#define BHT_OK (0)
-
-#define BHT_NO_WAIT 0x00000000
-#define BHT_WAIT_FOREVER 0xFFFFFFFF
-
-/**
- * vm_thread_sys_init
- *    initiation function for beihai thread system. Invoked at the beginning of beihai intiation.
- *
- * @return 0 if succuess.
- */
-int _vm_thread_sys_init(void);
-#ifdef _INSTRUMENT_TEST_ENABLED
-int vm_thread_sys_init_instr(const char*func_name);
-#define vm_thread_sys_init(void) vm_thread_sys_init_instr(__FUNCTION__)
-#else
-#define vm_thread_sys_init _vm_thread_sys_init
-#endif
-
-void vm_thread_sys_destroy(void);
-
-/**
- * This function creates a thread
- *
- * @param p_tid  [OUTPUT] the pointer of tid
- * @param start  main routine of the thread
- * @param arg  argument passed to main routine
- * @param stack_size  bytes of stack size
- *
- * @return 0 if success.
- */
-int _vm_thread_create(korp_tid *p_tid, thread_start_routine_t start, void *arg,
-        unsigned int stack_size);
-#ifdef _INSTRUMENT_TEST_ENABLED
-int vm_thread_create_instr(korp_tid *p_tid, thread_start_routine_t start, void *arg, unsigned int stack_size, const char*func_name);
-#define vm_thread_create(p_tid, start, arg, stack_size) vm_thread_create_instr(p_tid, start, arg, stack_size, __FUNCTION__)
-#else
-#define vm_thread_create _vm_thread_create
-#endif
-
-/**
- * This function creates a thread
- *
- * @param p_tid  [OUTPUT] the pointer of tid
- * @param start  main routine of the thread
- * @param arg  argument passed to main routine
- * @param stack_size  bytes of stack size
- * @param prio the priority
- *
- * @return 0 if success.
- */
-int _vm_thread_create_with_prio(korp_tid *p_tid, thread_start_routine_t start,
-        void *arg, unsigned int stack_size, int prio);
-#ifdef _INSTRUMENT_TEST_ENABLED
-int vm_thread_create_with_prio_instr(korp_tid *p_tid, thread_start_routine_t start, void *arg, unsigned int stack_size, int prio, const char*func_name);
-#define vm_thread_create_with_prio(p_tid, start, arg, stack_size) vm_thread_create_instr(p_tid, start, arg, stack_size, prio, __FUNCTION__)
-#else
-#define vm_thread_create_with_prio _vm_thread_create_with_prio
-#endif
-
-/**
- * This function never returns.
- *
- * @param code not used
- */
-void vm_thread_exit(void *code);
-
-/**
- * This function gets current thread id
- *
- * @return current thread id
- */
-korp_tid _vm_self_thread(void);
-#ifdef _INSTRUMENT_TEST_ENABLED
-korp_tid vm_self_thread_instr(const char*func_name);
-#define vm_self_thread(void) vm_self_thread_instr(__FUNCTION__)
-#else
-#define vm_self_thread _vm_self_thread
-#endif
-
-/**
- * This function saves a pointer in thread local storage. One thread can only save one pointer.
- *
- * @param idx  tls array index
- * @param ptr  pointer need save as TLS
- *
- * @return 0 if success
- */
-int _vm_tls_put(unsigned idx, void *ptr);
-#ifdef _INSTRUMENT_TEST_ENABLED
-int vm_tls_put_instr(unsigned idx, void *ptr, const char*func_name);
-#define vm_tls_put(idx, ptr) vm_tls_put_instr(idx, ptr, __FUNCTION__)
-#else
-#define vm_tls_put _vm_tls_put
-#endif
-
-/**
- * This function gets a pointer saved in TLS.
- *
- * @param idx  tls array index
- *
- * @return the pointer saved in TLS.
- */
-void *_vm_tls_get(unsigned idx);
-#ifdef _INSTRUMENT_TEST_ENABLED
-void *vm_tls_get_instr(unsigned idx, const char*func_name);
-#define vm_tls_get(idx) vm_tls_get_instr(idx, __FUNCTION__)
-#else
-#define vm_tls_get _vm_tls_get
-#endif
-
-#define vm_thread_testcancel(void)
-
-/**
- * This function creates a non-recursive mutex
- *
- * @param mutex [OUTPUT] pointer to mutex initialized.
- *
- * @return 0 if success
- */
-int _vm_mutex_init(korp_mutex *mutex);
-#ifdef INSTRUMENT_TEST_ENABLED
-int vm_mutex_init_instr(korp_mutex *mutex, const char*func_name);
-#define vm_mutex_init(mutex) vm_mutex_init_instr(mutex, __FUNCTION__)
-#else
-#define vm_mutex_init _vm_mutex_init
-#endif
-
-/**
- * This function creates a recursive mutex
- *
- * @param mutex [OUTPUT] pointer to mutex initialized.
- *
- * @return 0 if success
- */
-int _vm_recursive_mutex_init(korp_mutex *mutex);
-#ifdef INSTRUMENT_TEST_ENABLED
-int vm_recursive_mutex_init_instr(korp_mutex *mutex, const char*func_name);
-#define vm_recursive_mutex_init(mutex) vm_recursive_mutex_init_instr(mutex, __FUNCTION__)
-#else
-#define vm_recursive_mutex_init _vm_recursive_mutex_init
-#endif
-
-/**
- * This function destroys a mutex
- *
- * @param mutex  pointer to mutex need destroy
- *
- * @return 0 if success
- */
-int _vm_mutex_destroy(korp_mutex *mutex);
-#ifdef _INSTRUMENT_TEST_ENABLED
-int vm_mutex_destroy_instr(korp_mutex *mutex, const char*func_name);
-#define vm_mutex_destroy(mutex) vm_mutex_destroy_instr(mutex, __FUNCTION__)
-#else
-#define vm_mutex_destroy _vm_mutex_destroy
-#endif
-
-/**
- * This function locks the mutex
- *
- * @param mutex  pointer to mutex need lock
- *
- * @return Void
- */
-void vm_mutex_lock(korp_mutex *mutex);
-
-/**
- * This function locks the mutex without waiting
- *
- * @param mutex  pointer to mutex need lock
- *
- * @return 0 if success
- */
-int vm_mutex_trylock(korp_mutex *mutex);
-
-/**
- * This function unlocks the mutex
- *
- * @param mutex  pointer to mutex need unlock
- *
- * @return Void
- */
-void vm_mutex_unlock(korp_mutex *mutex);
-
-/**
- * This function creates a semaphone
- *
- * @param sem [OUTPUT] pointer to semaphone
- * @param c counter of semaphone
- *
- * @return 0 if success
- */
-int _vm_sem_init(korp_sem *sem, unsigned int c);
-#ifdef _INSTRUMENT_TEST_ENABLED
-int vm_sem_init_instr(korp_sem *sem, unsigned int c, const char*func_name);
-#define vm_sem_init(sem, c) vm_sem_init_instr(sem, c, __FUNCTION__)
-#else
-#define vm_sem_init _vm_sem_init
-#endif
-
-/**
- * This function destroys a semaphone
- *
- * @param sem pointer to semaphone need destroy
- *
- * @return 0 if success
- */
-int _vm_sem_destroy(korp_sem *sem);
-#ifdef _INSTRUMENT_TEST_ENABLED
-int vm_sem_destroy_instr(korp_sem *sem, const char*func_name);
-#define vm_sem_destroy(sem) vm_sem_destroy_instr(sem, __FUNCTION__)
-#else
-#define vm_sem_destroy _vm_sem_destroy
-#endif
-
-/**
- * This function performs wait operation on semaphone
- *
- * @param sem pointer to semaphone need perform wait operation
- *
- * @return 0 if success
- */
-int _vm_sem_wait(korp_sem *sem);
-#ifdef _INSTRUMENT_TEST_ENABLED
-int vm_sem_wait_instr(korp_sem *sem, const char*func_name);
-#define vm_sem_wait(sem) vm_sem_wait_instr(sem, __FUNCTION__)
-#else
-#define vm_sem_wait _vm_sem_wait
-#endif
-
-/**
- * This function performs wait operation on semaphone with a timeout
- *
- * @param sem  pointer to semaphone need perform wait operation
- * @param mills  wait milliseconds to return
- *
- * @return 0 if success
- * @return BH_TIMEOUT if time out
- */
-int _vm_sem_reltimedwait(korp_sem *sem, int mills);
-#ifdef _INSTRUMENT_TEST_ENABLED
-int vm_sem_reltimedwait_instr(korp_sem *sem, int mills, const char*func_name);
-#define vm_sem_reltimedwait(sem, mills) vm_sem_reltimedwait_instr(sem, mills, __FUNCTION__)
-#else
-#define vm_sem_reltimedwait _vm_sem_reltimedwait
-#endif
-
-/**
- * This function performs post operation on semaphone
- *
- * @param sem  pointer to semaphone need perform post operation
- *
- * @return 0 if success
- */
-int _vm_sem_post(korp_sem *sem);
-#ifdef _INSTRUMENT_TEST_ENABLED
-int vm_sem_post_instr(korp_sem *sem, const char*func_name);
-#define vm_sem_post(sem) vm_sem_post_instr(sem, __FUNCTION__)
-#else
-#define vm_sem_post _vm_sem_post
-#endif
-
-/**
- * This function creates a condition variable
- *
- * @param cond  [OUTPUT] pointer to condition variable
- *
- * @return 0 if success
- */
-int _vm_cond_init(korp_cond *cond);
-#ifdef INSTRUMENT_TEST_ENABLED
-int vm_cond_init_instr(korp_cond *cond, const char*func_name);
-#define vm_cond_init(cond) vm_cond_init_instr(cond, __FUNCTION__)
-#else
-#define vm_cond_init _vm_cond_init
-#endif
-
-/**
- * This function destroys condition variable
- *
- * @param cond  pointer to condition variable
- *
- * @return 0 if success
- */
-int _vm_cond_destroy(korp_cond *cond);
-#ifdef _INSTRUMENT_TEST_ENABLED
-int vm_cond_destroy_instr(korp_cond *cond, const char*func_name);
-#define vm_cond_destroy(cond) vm_cond_destroy_instr(cond, __FUNCTION__)
-#else
-#define vm_cond_destroy _vm_cond_destroy
-#endif
-
-/**
- * This function will block on a condition varible.
- *
- * @param cond  pointer to condition variable
- * @param mutex  pointer to mutex to protect the condition variable
- *
- * @return 0 if success
- */
-int _vm_cond_wait(korp_cond *cond, korp_mutex *mutex);
-#ifdef _INSTRUMENT_TEST_ENABLED
-int vm_cond_wait_instr(korp_cond *cond, korp_mutex *mutex, const char*func_name);
-#define vm_cond_wait(cond, mutex) vm_cond_wait_instr(cond, mutex, __FUNCTION__)
-#else
-#define vm_cond_wait _vm_cond_wait
-#endif
-
-/**
- * This function will block on a condition varible or return if time specified passes.
- *
- * @param cond  pointer to condition variable
- * @param mutex  pointer to mutex to protect the condition variable
- * @param mills  milliseconds to wait
- *
- * @return 0 if success
- */
-int _vm_cond_reltimedwait(korp_cond *cond, korp_mutex *mutex, int mills);
-#ifdef _INSTRUMENT_TEST_ENABLED
-int vm_cond_reltimedwait_instr(korp_cond *cond, korp_mutex *mutex, int mills, const char*func_name);
-#define vm_cond_reltimedwait(cond, mutex, mills) vm_cond_reltimedwait_instr(cond, mutex, mills, __FUNCTION__)
-#else
-#define vm_cond_reltimedwait _vm_cond_reltimedwait
-#endif
-
-/**
- * This function signals the condition variable
- *
- * @param cond  condition variable
- *
- * @return 0 if success
- */
-int _vm_cond_signal(korp_cond *cond);
-#ifdef _INSTRUMENT_TEST_ENABLED
-int vm_cond_signal_instr(korp_cond *cond, const char*func_name);
-#define vm_cond_signal(cond) vm_cond_signal_instr(cond, __FUNCTION__)
-#else
-#define vm_cond_signal _vm_cond_signal
-#endif
-
-int _vm_cond_broadcast(korp_cond *cond);
-#ifdef _INSTRUMENT_TEST_ENABLED
-int vm_cond_broadcast_instr(korp_cond *cond, const char*func_name);
-#define vm_cond_broadcast(cond) vm_cond_broadcast_instr(cond, __FUNCTION__)
-#else
-#define vm_cond_broadcast _vm_cond_broadcast
-#endif
-
-int _vm_thread_cancel(korp_tid thread);
-#ifdef _INSTRUMENT_TEST_ENABLED
-int vm_thread_cancel_instr(korp_tid thread, const char*func_name);
-#define vm_thread_cancel(thread) vm_thread_cancel_instr(thread, __FUNCTION__)
-#else
-#define vm_thread_cancel _vm_thread_cancel
-#endif
-
-int _vm_thread_join(korp_tid thread, void **value_ptr, int mills);
-#ifdef _INSTRUMENT_TEST_ENABLED
-int vm_thread_join_instr(korp_tid thread, void **value_ptr, int mills, const char*func_name);
-#define vm_thread_join(thread, value_ptr, mills) vm_thread_join_instr(thread, value_ptr, mills, __FUNCTION__)
-#else
-#define vm_thread_join _vm_thread_join
-#endif
-
-int _vm_thread_detach(korp_tid thread);
-#ifdef _INSTRUMENT_TEST_ENABLED
-int vm_thread_detach_instr(korp_tid thread, const char*func_name);
-#define vm_thread_detach(thread) vm_thread_detach_instr(thread, __FUNCTION__)
-#else
-#define vm_thread_detach _vm_thread_detach
-#endif
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* #ifndef _BH_THREAD_H */

core/shared/platform/include/bh_time.h

@@ -1,86 +0,0 @@
-/*
- * Copyright (C) 2019 Intel Corporation.  All rights reserved.
- * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
- */
-
-#ifndef _BH_TIME_H
-#define _BH_TIME_H
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#include "bh_config.h"
-#include "bh_types.h"
-#include "bh_platform.h"
-
-/*
- * This function returns milliseconds per tick.
- * @return milliseconds per tick.
- */
-extern uint64 _bh_time_get_tick_millisecond(void);
-#ifdef _INSTRUMENT_TEST_ENABLED
-extern uint64 bh_time_get_tick_millisecond_instr(const char*func_name);
-#define bh_time_get_tick_millisecond() bh_time_get_tick_millisecond_instr(__FUNCTION__)
-#else
-#define bh_time_get_tick_millisecond _bh_time_get_tick_millisecond
-#endif
-
-/*
- * This function returns milliseconds after boot.
- * @return milliseconds after boot.
- */
-extern uint64 _bh_time_get_boot_millisecond(void);
-#ifdef _INSTRUMENT_TEST_ENABLED
-extern uint64 bh_time_get_boot_millisecond_instr(const char*func_name);
-#define bh_time_get_boot_millisecond() bh_time_get_boot_millisecond_instr(__FUNCTION__)
-#else
-#define bh_time_get_boot_millisecond _bh_time_get_boot_millisecond
-#endif
-
-extern uint32 bh_get_tick_sec();
-#define  bh_get_tick_ms _bh_time_get_boot_millisecond
-
-/*
- * This function returns GMT milliseconds since from 1970.1.1, AKA UNIX time.
- * @return milliseconds since from 1970.1.1.
- */
-extern uint64 _bh_time_get_millisecond_from_1970(void);
-#ifdef _INSTRUMENT_TEST_ENABLED
-extern uint64 bh_time_get_millisecond_from_1970_instr(const char*func_name);
-#define bh_time_get_millisecond_from_1970() bh_time_get_millisecond_from_1970_instr(__FUNCTION__)
-#else
-#define bh_time_get_millisecond_from_1970 _bh_time_get_millisecond_from_1970
-#endif
-
-/**
- * This function sets timezone with specific hours.
- *
- * @param hours  represents the deviation (in hours) of the local time from GMT (can be a positive or a negative number)
- * @param half_hour  if true, adds half an hour to the local time calculation. For example, if hours=(+5) then the time will be GMT +5:30; if hours=(-5) then the time will be GMT -4:30.
- * @param daylight_save  if true, applies the daylight saving scheme when calculating the local time (adds one hour to the local time calculation)
- */
-extern void bh_set_timezone(int hours, int half_hour, int daylight_save);
-
-/**
- * This functions returns the offset in seconds which needs to be added GMT to get the local time.
- *
- *
- * @return offset in secords which needs to be added GMT to get the local time.
- */
-extern int bh_get_timezone_offset(void);
-
-size_t bh_time_strftime(char *s, size_t max, const char *format, int64 time);
-
-#ifdef _INSTRUMENT_TEST_ENABLED
-size_t bh_time_strftime_instr(char *s, size_t max, const char *format, int64 time, const char*func_name);
-#define bh_time_strftime(s, max, format, time) bh_time_strftime_instr(s, max, format, time, __FUNCTION__)
-#else
-#define bh_time_strftime _bh_time_strftime
-#endif
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif

core/shared/platform/include/bh_types.h

@@ -1,33 +0,0 @@
-/*
- * Copyright (C) 2019 Intel Corporation.  All rights reserved.
- * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
- */
-
-#ifndef _BH_TYPES_H
-#define _BH_TYPES_H
-
-#include "bh_config.h"
-
-typedef unsigned char uint8;
-typedef char int8;
-typedef unsigned short uint16;
-typedef short int16;
-typedef unsigned int uint32;
-typedef int int32;
-typedef float float32;
-typedef double float64;
-
-#include "bh_platform.h"
-
-#ifndef NULL
-#define NULL (void*)0
-#endif
-
-#ifndef __cplusplus
-#define true 1
-#define false 0
-#define inline __inline
-#endif
-
-#endif
-

core/shared/platform/include/platform_api_extension.h

@@ -0,0 +1,140 @@
+/*
+ * Copyright (C) 2019 Intel Corporation.  All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+ */
+
+#ifndef PLATFORM_API_EXTENSION_H
+#define PLATFORM_API_EXTENSION_H
+
+#include "platform_common.h"
+/**
+ * The related data structures should be defined
+ * in platform_internal.h
+ **/
+#include "platform_internal.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/***************************************************
+ *                                                 *
+ *                Extension interface              *
+ *                                                 *
+ ***************************************************/
+
+/**
+ * NOTES:
+ * 1. If you are building VM core only, it must be implemented to
+ *    enable multi-thread support, otherwise no need to implement it
+ * 2. To build the app-mgr and app-framework, you must implement it
+ */
+
+
+/**
+ * Ceates a thread
+ *
+ * @param p_tid  [OUTPUT] the pointer of tid
+ * @param start  main routine of the thread
+ * @param arg  argument passed to main routine
+ * @param stack_size  bytes of stack size
+ *
+ * @return 0 if success.
+ */
+int os_thread_create(korp_tid *p_tid, thread_start_routine_t start, void *arg,
+                     unsigned int stack_size);
+
+/**
+ * Creates a thread with priority
+ *
+ * @param p_tid  [OUTPUT] the pointer of tid
+ * @param start  main routine of the thread
+ * @param arg  argument passed to main routine
+ * @param stack_size  bytes of stack size
+ * @param prio the priority
+ *
+ * @return 0 if success.
+ */
+int os_thread_create_with_prio(korp_tid *p_tid, thread_start_routine_t start,
+                               void *arg, unsigned int stack_size, int prio);
+
+/**
+ * Waits for the thread specified by thread to terminate
+ *
+ * @param thread the thread to wait
+ * @param retval if not NULL, output the exit status of the terminated thread
+ *
+ * @return return 0 if success
+ */
+int os_thread_join(korp_tid thread, void **retval);
+
+/**
+ * Suspend execution of the calling thread for (at least)
+ * usec microseconds
+ *
+ * @param return 0 if success, -1 otherwise
+ */
+int os_usleep(uint32 usec);
+
+/**
+ * Creates a recursive mutex
+ *
+ * @param mutex [OUTPUT] pointer to mutex initialized.
+ *
+ * @return 0 if success
+ */
+int os_recursive_mutex_init(korp_mutex *mutex);
+
+/**
+ * This function creates a condition variable
+ *
+ * @param cond [OUTPUT] pointer to condition variable
+ *
+ * @return 0 if success
+ */
+int os_cond_init(korp_cond *cond);
+
+/**
+ * This function destroys condition variable
+ *
+ * @param cond pointer to condition variable
+ *
+ * @return 0 if success
+ */
+int os_cond_destroy(korp_cond *cond);
+
+/**
+ * Wait a condition variable.
+ *
+ * @param cond pointer to condition variable
+ * @param mutex pointer to mutex to protect the condition variable
+ *
+ * @return 0 if success
+ */
+int os_cond_wait(korp_cond *cond, korp_mutex *mutex);
+
+/**
+ * Wait a condition varible or return if time specified passes.
+ *
+ * @param cond pointer to condition variable
+ * @param mutex pointer to mutex to protect the condition variable
+ * @param useconds microseconds to wait
+ *
+ * @return 0 if success
+ */
+int os_cond_reltimedwait(korp_cond *cond, korp_mutex *mutex, int useconds);
+
+/**
+ * Signals the condition variable
+ *
+ * @param cond condition variable
+ *
+ * @return 0 if success
+ */
+int os_cond_signal(korp_cond *cond);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* #ifndef PLATFORM_API_EXTENSION_H */

core/shared/platform/include/platform_api_vmcore.h

@@ -0,0 +1,122 @@
+/*
+ * Copyright (C) 2019 Intel Corporation.  All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+ */
+
+#ifndef _PLATFORM_API_VMCORE_H
+#define _PLATFORM_API_VMCORE_H
+
+#include "platform_common.h"
+#include "platform_internal.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/****************************************************
+ *                     Section 1                    *
+ *        Interfaces required by the runtime        *
+ ****************************************************/
+
+/**
+ * Initialize the platform internal resources if needed,
+ * this function is called by wasm_runtime_init() and
+ * wasm_runtime_full_init()
+ *
+ * @return 0 if success
+ */
+int bh_platform_init();
+
+/**
+ * Destroy the platform internal resources if needed,
+ * this function is called by wasm_runtime_destroy()
+ */
+void bh_platform_destroy();
+
+/**
+ ******** memory allocator APIs **********
+ */
+
+void *os_malloc(unsigned size);
+
+void *os_realloc(void *ptr, unsigned size);
+
+void os_free(void *ptr);
+
+/**
+ * Note: the above APIs can simply return NULL if wasm runtime
+ *       isn't initialized with Alloc_With_System_Allocator.
+ *       Refer to wasm_runtime_full_init().
+ */
+
+
+int os_printf(const char *format, ...);
+
+int os_vprintf(const char *format, va_list ap);
+
+/**
+ * Get microseconds after boot.
+ */
+uint64 os_time_get_boot_microsecond(void);
+
+/**
+ * Get current thread id.
+ * Implementation optional: Used by runtime for logging only.
+ */
+korp_tid os_self_thread(void);
+
+/**
+ ************** mutext APIs ***********
+ *  vmcore:  Not required until pthread is supported by runtime
+ *  app-mgr: Must be implemented
+ */
+
+int os_mutex_init(korp_mutex *mutex);
+
+int os_mutex_destroy(korp_mutex *mutex);
+
+void os_mutex_lock(korp_mutex *mutex);
+
+void os_mutex_unlock(korp_mutex *mutex);
+
+
+/**************************************************
+ *                    Section 2                   *
+ *            APIs required by WAMR AOT           *
+ **************************************************/
+
+/* Memory map modes */
+enum {
+    MMAP_PROT_NONE = 0,
+    MMAP_PROT_READ = 1,
+    MMAP_PROT_WRITE = 2,
+    MMAP_PROT_EXEC = 4
+};
+
+/* Memory map flags */
+enum {
+    MMAP_MAP_NONE = 0,
+    /* Put the mapping into 0 to 2 G, supported only on x86_64 */
+    MMAP_MAP_32BIT = 1,
+    /* Don't interpret addr as a hint: place the mapping at exactly
+       that address. */
+    MMAP_MAP_FIXED = 2
+};
+
+void *os_mmap(void *hint, unsigned int size, int prot, int flags);
+void os_munmap(void *addr, uint32 size);
+int os_mprotect(void *addr, uint32 size, int prot);
+
+/**
+ * Flush cpu data cache, in some CPUs, after applying relocation to the
+ * AOT code, the code may haven't been written back to the cpu data cache,
+ * which may cause unexpected behaviour when executing the AOT code.
+ * Implement this function if required, or just leave it empty.
+ */
+void os_dcache_flush(void);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* #ifndef _PLATFORM_API_VMCORE_H */

core/shared/platform/include/platform_common.h

@@ -0,0 +1,73 @@
+/*
+ * Copyright (C) 2019 Intel Corporation.  All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+ */
+
+#ifndef _PLATFORM_COMMON_H
+#define _PLATFORM_COMMON_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include "../../../config.h"
+#include "platform_internal.h"
+
+#define BH_MAX_THREAD 32
+
+#define BHT_ERROR (-1)
+#define BHT_TIMED_OUT (1)
+#define BHT_OK (0)
+
+#define BHT_NO_WAIT 0x00000000
+#define BHT_WAIT_FOREVER 0xFFFFFFFF
+
+#define BH_KB (1024)
+#define BH_MB ((BH_KB)*1024)
+#define BH_GB ((BH_MB)*1024)
+
+#ifndef BH_MALLOC
+#define BH_MALLOC os_malloc
+#endif
+
+#ifndef BH_FREE
+#define BH_FREE os_free
+#endif
+
+void *BH_MALLOC(unsigned int size);
+void BH_FREE(void *ptr);
+
+#ifndef NULL
+#define NULL (void*)0
+#endif
+
+#ifndef __cplusplus
+#define true 1
+#define false 0
+#define inline __inline
+#endif
+
+/* Return the offset of the given field in the given type */
+#ifndef offsetof
+#define offsetof(Type, field) ((size_t)(&((Type *)0)->field))
+#endif
+
+typedef uint8_t uint8;
+typedef int8_t int8;
+typedef uint16_t uint16;
+typedef int16_t int16;
+typedef uint32_t uint32;
+typedef int32_t int32;
+typedef float float32;
+typedef double float64;
+typedef uint64_t uint64;
+typedef int64_t int64;
+
+typedef void* (*thread_start_routine_t)(void*);
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* #ifndef _PLATFORM_COMMON_H */

core/shared/platform/linux-sgx/bh_assert.c

@@ -1,58 +0,0 @@
-/*
- * Copyright (C) 2019 Intel Corporation.  All rights reserved.
- * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
- */
-
-#include "bh_platform.h"
-#include "bh_assert.h"
-#include <stdarg.h>
-#include <stdio.h>
-#include <stdlib.h>
-
-#ifdef BH_TEST
-#include <setjmp.h>
-#endif
-
-#ifdef BH_TEST
-/* for exception throwing */
-jmp_buf bh_test_jb;
-#endif
-#define FIXED_BUFFER_SIZE (1<<9)
-
-void bh_assert_internal(int v, const char *file_name, int line_number,
-        const char *expr_string)
-{
-    if (v)
-        return;
-
-    if (!file_name)
-        file_name = "NULL FILENAME";
-    if (!expr_string)
-        expr_string = "NULL EXPR_STRING";
-
-    bh_printf_sgx("\nASSERTION FAILED: %s, at FILE=%s, LINE=%d\n", expr_string,
-            file_name, line_number);
-
-#ifdef BH_TEST
-    longjmp(bh_test_jb, 1);
-#endif
-
-    abort();
-}
-
-void bh_debug_internal(const char *file_name, int line_number, const char *fmt,
-        ...)
-{
-#ifndef JEFF_TEST_VERIFIER
-    va_list args;
-    char msg[FIXED_BUFFER_SIZE] = { '\0' };
-
-    va_start(args, fmt);
-    vsnprintf(msg, FIXED_BUFFER_SIZE, fmt, args);
-    va_end(args);
-    bh_printf_sgx("\nDebug info FILE=%s, LINE=%d: ", file_name, line_number);
-    bh_printf_sgx(msg);
-    bh_printf_sgx("\n");
-#endif
-}
-

core/shared/platform/linux-sgx/bh_platform.h

@@ -1,126 +0,0 @@
-/*
- * Copyright (C) 2019 Intel Corporation.  All rights reserved.
- * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
- */
-
-#ifndef _BH_PLATFORM_H
-#define _BH_PLATFORM_H
-
-#include "bh_config.h"
-#include "bh_types.h"
-#include <inttypes.h>
-#include <stdbool.h>
-#include <assert.h>
-#include <time.h>
-#include <string.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <math.h>
-#include <stdarg.h>
-#include <ctype.h>
-#include <limits.h>
-#include <errno.h>
-#include <sgx_thread.h>
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-typedef void (*bh_print_function_t)(const char* message);
-void bh_set_print_function(bh_print_function_t pf);
-
-extern int bh_printf_sgx(const char *message, ...);
-extern int bh_vprintf_sgx(const char * format, va_list arg);
-
-typedef uint64_t uint64;
-typedef int64_t int64;
-
-#ifndef BH_PLATFORM_LINUX_SGX
-#define BH_PLATFORM_LINUX_SGX
-#endif
-
-/* NEED qsort */
-
-#define _STACK_SIZE_ADJUSTMENT (32 * 1024)
-
-/* Stack size of applet threads's native part.  */
-#define BH_APPLET_PRESERVED_STACK_SIZE      (8 * 1024 + _STACK_SIZE_ADJUSTMENT)
-
-/* Default thread priority */
-#define BH_THREAD_DEFAULT_PRIORITY 0
-
-#define BH_ROUTINE_MODIFIER
-
-#define BHT_TIMEDOUT ETIMEDOUT
-
-#define INVALID_THREAD_ID 0xFFffFFff
-
-typedef int korp_sem;
-typedef void* (*thread_start_routine_t)(void*);
-typedef sgx_thread_mutex_t korp_mutex;
-typedef sgx_thread_t korp_tid;
-typedef sgx_thread_t korp_thread;
-typedef sgx_thread_cond_t korp_cond;
-
-void *os_malloc(unsigned size);
-void *os_realloc(void *ptr, unsigned size);
-void os_free(void *ptr);
-
-#define bh_printf bh_printf_sgx
-
-int snprintf(char *buffer, size_t count, const char *format, ...);
-int strncasecmp(const char *s1, const char *s2, size_t n);
-double fmod(double x, double y);
-float fmodf(float x, float y);
-double sqrt(double x);
-
-#define BH_WAIT_FOREVER 0xFFFFFFFF
-
-#ifndef NULL
-#  define NULL ((void*) 0)
-#endif
-
-/**
- * Return the offset of the given field in the given type.
- *
- * @param Type the type containing the filed
- * @param field the field in the type
- *
- * @return the offset of field in Type
- */
-#ifndef offsetof
-#define offsetof(Type, field) ((size_t)(&((Type *)0)->field))
-#endif
-
-#define bh_assert assert
-
-int bh_platform_init();
-
-/* MMAP mode */
-enum {
-    MMAP_PROT_NONE = 0,
-    MMAP_PROT_READ = 1,
-    MMAP_PROT_WRITE = 2,
-    MMAP_PROT_EXEC = 4
-};
-
-/* MMAP flags */
-enum {
-    MMAP_MAP_NONE = 0,
-    /* Put the mapping into 0 to 2 G, supported only on x86_64 */
-    MMAP_MAP_32BIT = 1,
-    /* Don't interpret addr as a hint: place the mapping at exactly
-       that address. */
-    MMAP_MAP_FIXED = 2
-};
-
-void *bh_mmap(void *hint, unsigned int size, int prot, int flags);
-void bh_munmap(void *addr, uint32 size);
-int bh_mprotect(void *addr, uint32 size, int prot);
-#define bh_dcache_flush() (void)0
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif

core/shared/platform/linux-sgx/bh_thread.c

@@ -1,181 +0,0 @@
-/*
- * Copyright (C) 2019 Intel Corporation.  All rights reserved.
- * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
- */
-
-#include "bh_thread.h"
-#include "bh_assert.h"
-#include <stdio.h>
-#include <stdlib.h>
-#include <sgx_thread.h>
-
-int _vm_thread_sys_init()
-{
-    return 0;
-}
-
-void vm_thread_sys_destroy(void)
-{
-}
-
-int _vm_thread_create_with_prio(korp_tid *tid, thread_start_routine_t start,
-                                void *arg, unsigned int stack_size, int prio)
-{
-    return BHT_ERROR;
-    // return BHT_OK;
-}
-
-int _vm_thread_create(korp_tid *tid, thread_start_routine_t start, void *arg,
-                      unsigned int stack_size)
-{
-    return _vm_thread_create_with_prio(tid, start, arg, stack_size,
-                                       BH_THREAD_DEFAULT_PRIORITY);
-}
-
-korp_tid _vm_self_thread()
-{
-    return sgx_thread_self();
-}
-
-void vm_thread_exit(void * code)
-{
-}
-
-// storage for one thread
-static __thread void *_tls_store = NULL;
-
-void *_vm_tls_get(unsigned idx)
-{
-    return _tls_store;
-}
-
-int _vm_tls_put(unsigned idx, void * tls)
-{
-    _tls_store = tls;
-    return BHT_OK;
-    //return BHT_ERROR;
-}
-
-int _vm_mutex_init(korp_mutex *mutex)
-{
-    sgx_thread_mutex_t m = SGX_THREAD_MUTEX_INITIALIZER;
-    *mutex = m;
-    return BHT_OK;
-}
-
-int _vm_recursive_mutex_init(korp_mutex *mutex)
-{
-    sgx_thread_mutex_t m = SGX_THREAD_RECURSIVE_MUTEX_INITIALIZER;
-    *mutex = m;
-    return BHT_OK;
-}
-
-int _vm_mutex_destroy(korp_mutex *mutex)
-{
-    sgx_thread_mutex_destroy(mutex);
-    return BHT_OK;
-}
-
-/* Returned error (EINVAL, EAGAIN and EDEADLK) from
- locking the mutex indicates some logic error present in
- the program somewhere.
- Don't try to recover error for an existing unknown error.*/
-void vm_mutex_lock(korp_mutex *mutex)
-{
-    sgx_thread_mutex_lock(mutex);
-}
-
-int vm_mutex_trylock(korp_mutex *mutex)
-{
-    return (sgx_thread_mutex_trylock(mutex) == 0? BHT_OK: BHT_ERROR);
-}
-
-/* Returned error (EINVAL, EAGAIN and EPERM) from
- unlocking the mutex indicates some logic error present
- in the program somewhere.
- Don't try to recover error for an existing unknown error.*/
-void vm_mutex_unlock(korp_mutex *mutex)
-{
-    sgx_thread_mutex_unlock(mutex);
-}
-
-int _vm_sem_init(korp_sem* sem, unsigned int c)
-{
-    return BHT_OK;
-    //return BHT_ERROR;
-}
-
-int _vm_sem_destroy(korp_sem *sem)
-{
-    return BHT_OK;
-    //return BHT_ERROR;
-}
-
-int _vm_sem_wait(korp_sem *sem)
-{
-    return BHT_OK;
-    //return BHT_ERROR;
-}
-
-int _vm_sem_reltimedwait(korp_sem *sem, int mills)
-{
-    return BHT_OK;
-    //return BHT_ERROR;
-}
-
-int _vm_sem_post(korp_sem *sem)
-{
-    return BHT_OK;
-    //return BHT_ERROR;
-}
-
-int _vm_cond_init(korp_cond *cond)
-{
-    return BHT_OK;
-    //return BHT_ERROR;
-}
-
-int _vm_cond_destroy(korp_cond *cond)
-{
-    return BHT_OK;
-    //return BHT_ERROR;
-}
-
-int _vm_cond_wait(korp_cond *cond, korp_mutex *mutex)
-{
-    return BHT_OK;
-    //return BHT_ERROR;
-}
-
-int _vm_cond_reltimedwait(korp_cond *cond, korp_mutex *mutex, int mills)
-{
-    return BHT_OK;
-    //return BHT_ERROR;
-}
-
-int _vm_cond_signal(korp_cond *cond)
-{
-    return BHT_OK;
-    //return BHT_ERROR;
-}
-
-int _vm_cond_broadcast(korp_cond *cond)
-{
-    return BHT_OK;
-    //return BHT_ERROR;
-}
-
-int _vm_thread_cancel(korp_tid thread)
-{
-    return 0;
-}
-
-int _vm_thread_join(korp_tid thread, void **value_ptr, int mills)
-{
-    return 0;
-}
-
-int _vm_thread_detach(korp_tid thread)
-{
-    return 0;
-}

core/shared/platform/linux-sgx/bh_time.c

@@ -1,53 +0,0 @@
-/*
- * Copyright (C) 2019 Intel Corporation.  All rights reserved.
- * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
- */
-
-#include "bh_time.h"
-
-#include <unistd.h>
-#include <stdio.h>
-#include <time.h>
-
-/*
- * This function returns milliseconds per tick.
- * @return milliseconds per tick.
- */
-uint64 _bh_time_get_tick_millisecond()
-{
-    //TODO:
-    return 0;
-}
-
-/*
- * This function returns milliseconds after boot.
- * @return milliseconds after boot.
- */
-uint64 _bh_time_get_boot_millisecond()
-{
-   //TODO
-   return 0;
-}
-
-uint32 bh_get_tick_sec()
-{
-    //TODO
-    return 0;
-}
-
-/*
- * This function returns GMT time milliseconds since from 1970.1.1, AKA UNIX time.
- * @return milliseconds since from 1970.1.1.
- */
-uint64 _bh_time_get_millisecond_from_1970()
-{
-   //TODO
-   return 0;
-}
-
-size_t _bh_time_strftime(char *s, size_t max, const char *format, int64 time)
-{
-  //TODO
-  return 0;
-}
-

core/shared/platform/linux-sgx/platform_internal.h

@@ -0,0 +1,53 @@
+/*
+ * Copyright (C) 2019 Intel Corporation.  All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+ */
+
+#ifndef _PLATFORM_INTERNAL_H
+#define _PLATFORM_INTERNAL_H
+
+#include <inttypes.h>
+#include <stdbool.h>
+#include <assert.h>
+#include <time.h>
+#include <string.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <math.h>
+#include <unistd.h>
+#include <stdarg.h>
+#include <ctype.h>
+#include <limits.h>
+#include <errno.h>
+#include <sgx_thread.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifndef BH_PLATFORM_LINUX_SGX
+#define BH_PLATFORM_LINUX_SGX
+#endif
+
+#define _STACK_SIZE_ADJUSTMENT (32 * 1024)
+
+/* Stack size of applet threads's native part.  */
+#define BH_APPLET_PRESERVED_STACK_SIZE      (8 * 1024 + _STACK_SIZE_ADJUSTMENT)
+
+/* Default thread priority */
+#define BH_THREAD_DEFAULT_PRIORITY 0
+
+typedef sgx_thread_t korp_thread;
+typedef sgx_thread_t korp_tid;
+typedef sgx_thread_mutex_t korp_mutex;
+typedef sgx_thread_cond_t korp_cond;
+
+typedef void (*os_print_function_t)(const char* message);
+void os_set_print_function(os_print_function_t pf);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* end of _PLATFORM_INTERNAL_H */
+

core/shared/platform/linux-sgx/sgx_platform.c

@@ -3,22 +3,27 @@
  * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
  */
 
-#include "bh_common.h"
-#include "bh_platform.h"
+#include "platform_api_vmcore.h"
+#include "platform_api_extension.h"
 
-#include <unistd.h>
 #if WASM_ENABLE_AOT != 0
 #include "sgx_rsrv_mem_mngr.h"
 #endif
 
 #define FIXED_BUFFER_SIZE (1<<9)
-static bh_print_function_t print_function = NULL;
+
+static os_print_function_t print_function = NULL;
 
 int bh_platform_init()
 {
     return 0;
 }
 
+void
+bh_platform_destroy()
+{
+}
+
 void *
 os_malloc(unsigned size)
 {
@@ -47,12 +52,12 @@ int puts(const char *s)
     return 0;
 }
 
-void bh_set_print_function(bh_print_function_t pf)
+void os_set_print_function(os_print_function_t pf)
 {
     print_function = pf;
 }
 
-int bh_printf_sgx(const char *message, ...)
+int os_printf(const char *message, ...)
 {
     if (print_function != NULL) {
         char msg[FIXED_BUFFER_SIZE] = { '\0' };
@@ -66,7 +71,7 @@ int bh_printf_sgx(const char *message, ...)
     return 0;
 }
 
-int bh_vprintf_sgx(const char * format, va_list arg)
+int os_vprintf(const char * format, va_list arg)
 {
     if (print_function != NULL) {
         char msg[FIXED_BUFFER_SIZE] = { '\0' };
@@ -77,7 +82,7 @@ int bh_vprintf_sgx(const char * format, va_list arg)
     return 0;
 }
 
-void* bh_mmap(void *hint, unsigned int size, int prot, int flags)
+void* os_mmap(void *hint, unsigned int size, int prot, int flags)
 {
 #if WASM_ENABLE_AOT != 0
     int mprot = 0;
@@ -87,7 +92,7 @@ void* bh_mmap(void *hint, unsigned int size, int prot, int flags)
 
     ret = sgx_alloc_rsrv_mem(alignedSize);
     if (ret == NULL) {
-        bh_printf_sgx("bh_mmap(size=%d, alignedSize=%d, prot=0x%x) failed.",size, alignedSize, prot);
+        os_printf_sgx("os_mmap(size=%d, alignedSize=%d, prot=0x%x) failed.",size, alignedSize, prot);
         return NULL;
     }
     if (prot & MMAP_PROT_READ)
@@ -98,7 +103,7 @@ void* bh_mmap(void *hint, unsigned int size, int prot, int flags)
         mprot |= SGX_PROT_EXEC;
     st = sgx_tprotect_rsrv_mem(ret, alignedSize, mprot);
     if (st != SGX_SUCCESS){
-	bh_printf_sgx("bh_mmap(size=%d,prot=0x%x) failed to set protect.",size, prot);
+	os_printf_sgx("os_mmap(size=%d,prot=0x%x) failed to set protect.",size, prot);
         sgx_free_rsrv_mem(ret, alignedSize);
         return NULL;
     }
@@ -109,14 +114,14 @@ void* bh_mmap(void *hint, unsigned int size, int prot, int flags)
 #endif
 }
 
-void bh_munmap(void *addr, uint32 size)
+void os_munmap(void *addr, uint32 size)
 {
 #if WASM_ENABLE_AOT != 0
     sgx_free_rsrv_mem(addr, size);
 #endif
 }
 
-int bh_mprotect(void *addr, uint32 size, int prot)
+int os_mprotect(void *addr, uint32 size, int prot)
 {
 #if WASM_ENABLE_AOT != 0
     int mprot = 0;
@@ -129,10 +134,16 @@ int bh_mprotect(void *addr, uint32 size, int prot)
     if (prot & MMAP_PROT_EXEC)
         mprot |= SGX_PROT_EXEC;
     st = sgx_tprotect_rsrv_mem(addr, size, mprot);
-    if (st != SGX_SUCCESS) bh_printf_sgx("bh_mprotect(addr=0x%lx,size=%d,prot=0x%x) failed.", addr, size, prot);
+    if (st != SGX_SUCCESS) os_printf_sgx("os_mprotect(addr=0x%lx,size=%d,prot=0x%x) failed.", addr, size, prot);
 
     return (st == SGX_SUCCESS? 0:-1);
 #else
     return -1;
 #endif
 }
+
+void
+os_dcache_flush(void)
+{
+}
+

core/shared/platform/linux-sgx/sgx_thread.c

@@ -0,0 +1,44 @@
+/*
+ * Copyright (C) 2019 Intel Corporation.  All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+ */
+
+#include "platform_api_vmcore.h"
+#include "platform_api_extension.h"
+
+korp_tid os_self_thread()
+{
+    return sgx_thread_self();
+}
+
+int os_mutex_init(korp_mutex *mutex)
+{
+    sgx_thread_mutex_t m = SGX_THREAD_MUTEX_INITIALIZER;
+    *mutex = m;
+    return BHT_OK;
+}
+
+int os_mutex_destroy(korp_mutex *mutex)
+{
+    sgx_thread_mutex_destroy(mutex);
+    return BHT_OK;
+}
+
+/* Returned error (EINVAL, EAGAIN and EDEADLK) from
+ locking the mutex indicates some logic error present in
+ the program somewhere.
+ Don't try to recover error for an existing unknown error.*/
+void os_mutex_lock(korp_mutex *mutex)
+{
+    sgx_thread_mutex_lock(mutex);
+}
+
+/* Returned error (EINVAL, EAGAIN and EPERM) from
+ unlocking the mutex indicates some logic error present
+ in the program somewhere.
+ Don't try to recover error for an existing unknown error.*/
+void os_mutex_unlock(korp_mutex *mutex)
+{
+    sgx_thread_mutex_unlock(mutex);
+}
+

core/shared/platform/linux-sgx/sgx_time.c

@@ -0,0 +1,14 @@
+/*
+ * Copyright (C) 2019 Intel Corporation.  All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+ */
+
+#include "platform_api_vmcore.h"
+
+uint64
+os_time_get_boot_microsecond()
+{
+    /* TODO */
+    return 0;
+}
+

core/shared/platform/linux-sgx/shared_platform.cmake

@@ -3,6 +3,8 @@
 
 set (PLATFORM_SHARED_DIR ${CMAKE_CURRENT_LIST_DIR})
 
+add_definitions(-DBH_PLATFORM_LINUX_SGX)
+
 include_directories(${PLATFORM_SHARED_DIR})
 include_directories(${PLATFORM_SHARED_DIR}/../include)
 

core/shared/platform/linux/bh_assert.c

@@ -1,58 +0,0 @@
-/*
- * Copyright (C) 2019 Intel Corporation.  All rights reserved.
- * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
- */
-
-#include "bh_platform.h"
-#include "bh_assert.h"
-#include <stdarg.h>
-#include <stdio.h>
-#include <stdlib.h>
-
-#ifdef BH_TEST
-#include <setjmp.h>
-#endif
-
-#ifdef BH_TEST
-/* for exception throwing */
-jmp_buf bh_test_jb;
-#endif
-
-void bh_assert_internal(int v, const char *file_name, int line_number,
-        const char *expr_string)
-{
-    if (v)
-        return;
-
-    if (!file_name)
-        file_name = "NULL FILENAME";
-    if (!expr_string)
-        expr_string = "NULL EXPR_STRING";
-
-    printf("\nASSERTION FAILED: %s, at FILE=%s, LINE=%d\n", expr_string,
-            file_name, line_number);
-
-#ifdef BH_TEST
-    longjmp(bh_test_jb, 1);
-#endif
-
-    abort();
-}
-
-void bh_debug_internal(const char *file_name, int line_number, const char *fmt,
-        ...)
-{
-#ifndef JEFF_TEST_VERIFIER
-    va_list args;
-
-    va_start(args, fmt);
-    bh_assert(file_name);
-
-    printf("\nDebug info FILE=%s, LINE=%d: ", file_name, line_number);
-    vprintf(fmt, args);
-
-    va_end(args);
-    printf("\n");
-#endif
-}
-

core/shared/platform/linux/bh_platform.c

@@ -1,182 +0,0 @@
-/*
- * Copyright (C) 2019 Intel Corporation.  All rights reserved.
- * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
- */
-
-#include "bh_platform.h"
-#include "bh_common.h"
-#include "bh_assert.h"
-
-#include <sys/stat.h>
-#include <fcntl.h>
-#include <unistd.h>
-#include <sys/mman.h>
-
-int
-bh_platform_init()
-{
-    return 0;
-}
-
-void *
-os_malloc(unsigned size)
-{
-    return malloc(size);
-}
-
-void *
-os_realloc(void *ptr, unsigned size)
-{
-    return realloc(ptr, size);
-}
-
-void
-os_free(void *ptr)
-{
-    free(ptr);
-}
-
-char*
-bh_read_file_to_buffer(const char *filename, uint32 *ret_size)
-{
-    char *buffer;
-    int file;
-    uint32 file_size, read_size;
-    struct stat stat_buf;
-
-    if (!filename || !ret_size) {
-        printf("Read file to buffer failed: invalid filename or ret size.\n");
-        return NULL;
-    }
-
-    if ((file = open(filename, O_RDONLY, 0)) == -1) {
-        printf("Read file to buffer failed: open file %s failed.\n",
-               filename);
-        return NULL;
-    }
-
-    if (fstat(file, &stat_buf) != 0) {
-        printf("Read file to buffer failed: fstat file %s failed.\n",
-               filename);
-        close(file);
-        return NULL;
-    }
-
-    file_size = (uint32)stat_buf.st_size;
-
-    if (!(buffer = BH_MALLOC(file_size))) {
-        printf("Read file to buffer failed: alloc memory failed.\n");
-        close(file);
-        return NULL;
-    }
-
-    read_size = (uint32)read(file, buffer, file_size);
-    close(file);
-
-    if (read_size < file_size) {
-        printf("Read file to buffer failed: read file content failed.\n");
-        BH_FREE(buffer);
-        return NULL;
-    }
-
-    *ret_size = file_size;
-    return buffer;
-}
-
-void *
-bh_mmap(void *hint, uint32 size, int prot, int flags)
-{
-    int map_prot = PROT_NONE;
-    int map_flags = MAP_ANONYMOUS | MAP_PRIVATE;
-    uint64 request_size, page_size;
-    uint8 *addr, *addr_aligned;
-    uint32 i;
-
-    /* align to 2M if no less than 2M, else align to 4K */
-    page_size = size < 2 * 1024 * 1024 ? 4096 : 2 * 1024 * 1024;
-    request_size = (size + page_size - 1) & ~(page_size - 1);
-    request_size += page_size;
-
-    if (request_size >= UINT32_MAX)
-        return NULL;
-
-    if (prot & MMAP_PROT_READ)
-        map_prot |= PROT_READ;
-
-    if (prot & MMAP_PROT_WRITE)
-        map_prot |= PROT_WRITE;
-
-    if (prot & MMAP_PROT_EXEC)
-        map_prot |= PROT_EXEC;
-
-#if defined(BUILD_TARGET_X86_64) || defined(BUILD_TARGET_AMD_64)
-    if (flags & MMAP_MAP_32BIT)
-        map_flags |= MAP_32BIT;
-#endif
-
-    if (flags & MMAP_MAP_FIXED)
-        map_flags |= MAP_FIXED;
-
-    /* try 5 times */
-    for (i = 0; i < 5; i ++) {
-        addr = mmap(hint, size, map_prot, map_flags, -1, 0);
-        if (addr != MAP_FAILED)
-            break;
-    }
-    if (addr == MAP_FAILED)
-        return NULL;
-
-    addr_aligned = (uint8*)(uintptr_t)
-        (((uint64)(uintptr_t)addr + page_size - 1) & ~(page_size - 1));
-
-    /* Unmap memory allocated before the aligned base address */
-    if (addr != addr_aligned) {
-        uint32 prefix_size = (uint32)(addr_aligned - addr);
-        munmap(addr, prefix_size);
-        request_size -= prefix_size;
-    }
-
-    /* Unmap memory allocated after the potentially unaligned end */
-    if (size != request_size) {
-        uint32 suffix_size = (uint32)(request_size - size);
-        munmap(addr_aligned + size, suffix_size);
-        request_size -= size;
-    }
-
-    if (size >= 2 * 1024 * 1024) {
-        /* Try to use huge page to improve performance */
-        if (!madvise(addr, size, MADV_HUGEPAGE))
-            /* make huge page become effective */
-            memset(addr, 0, size);
-    }
-
-    return addr_aligned;
-}
-
-void
-bh_munmap(void *addr, uint32 size)
-{
-    if (addr)
-        munmap(addr, size);
-}
-
-int
-bh_mprotect(void *addr, uint32 size, int prot)
-{
-    int map_prot = PROT_NONE;
-
-    if (!addr)
-        return 0;
-
-    if (prot & MMAP_PROT_READ)
-        map_prot |= PROT_READ;
-
-    if (prot & MMAP_PROT_WRITE)
-        map_prot |= PROT_WRITE;
-
-    if (prot & MMAP_PROT_EXEC)
-        map_prot |= PROT_EXEC;
-
-    return mprotect(addr, size, map_prot);
-}
-

core/shared/platform/linux/bh_platform.h

@@ -1,130 +0,0 @@
-/*
- * Copyright (C) 2019 Intel Corporation.  All rights reserved.
- * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
- */
-
-#ifndef _BH_PLATFORM_H
-#define _BH_PLATFORM_H
-
-#include "bh_config.h"
-#include "bh_types.h"
-#include <inttypes.h>
-#include <stdbool.h>
-#include <assert.h>
-#include <time.h>
-#include <string.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <math.h>
-#include <stdarg.h>
-#include <ctype.h>
-#include <pthread.h>
-#include <semaphore.h>
-#include <limits.h>
-#include <fcntl.h>
-#include <errno.h>
-#include <sys/socket.h>
-#include <sys/stat.h>
-#include <netinet/in.h>
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-typedef uint64_t uint64;
-typedef int64_t int64;
-
-extern void DEBUGME(void);
-
-#define DIE do{bh_debug("Die here\n\n\n\n\n\n\n\n\n\n\n\n\n\n"); DEBUGME(void); while(1);}while(0)
-
-#ifndef BH_PLATFORM_LINUX
-#define BH_PLATFORM_LINUX
-#endif
-
-/* NEED qsort */
-
-#define _STACK_SIZE_ADJUSTMENT (32 * 1024)
-
-/* Stack size of applet threads's native part.  */
-#define BH_APPLET_PRESERVED_STACK_SIZE      (8 * 1024 + _STACK_SIZE_ADJUSTMENT)
-
-/* Default thread priority */
-#define BH_THREAD_DEFAULT_PRIORITY 0
-
-#define BH_ROUTINE_MODIFIER
-
-#define BHT_TIMEDOUT ETIMEDOUT
-
-#define INVALID_THREAD_ID 0xFFffFFff
-
-typedef pthread_t korp_tid;
-typedef pthread_mutex_t korp_mutex;
-typedef sem_t korp_sem;
-typedef pthread_cond_t korp_cond;
-typedef pthread_t korp_thread;
-typedef void* (*thread_start_routine_t)(void*);
-
-void *os_malloc(unsigned size);
-void *os_realloc(void *ptr, unsigned size);
-void os_free(void *ptr);
-
-#define bh_printf printf
-
-int snprintf(char *buffer, size_t count, const char *format, ...);
-double fmod(double x, double y);
-float fmodf(float x, float y);
-double sqrt(double x);
-
-#define BH_WAIT_FOREVER 0xFFFFFFFF
-
-#ifndef NULL
-#  define NULL ((void*) 0)
-#endif
-
-/**
- * Return the offset of the given field in the given type.
- *
- * @param Type the type containing the filed
- * @param field the field in the type
- *
- * @return the offset of field in Type
- */
-#ifndef offsetof
-#define offsetof(Type, field) ((size_t)(&((Type *)0)->field))
-#endif
-
-#define bh_assert assert
-
-char *bh_read_file_to_buffer(const char *filename, uint32 *ret_size);
-
-int bh_platform_init();
-
-/* MMAP mode */
-enum {
-    MMAP_PROT_NONE = 0,
-    MMAP_PROT_READ = 1,
-    MMAP_PROT_WRITE = 2,
-    MMAP_PROT_EXEC = 4
-};
-
-/* MMAP flags */
-enum {
-    MMAP_MAP_NONE = 0,
-    /* Put the mapping into 0 to 2 G, supported only on x86_64 */
-    MMAP_MAP_32BIT = 1,
-    /* Don't interpret addr as a hint: place the mapping at exactly
-       that address. */
-    MMAP_MAP_FIXED = 2
-};
-
-void *bh_mmap(void *hint, unsigned int size, int prot, int flags);
-void bh_munmap(void *addr, uint32 size);
-int bh_mprotect(void *addr, uint32 size, int prot);
-#define bh_dcache_flush() (void)0
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif

core/shared/platform/linux/bh_platform_log.c

@@ -1,30 +0,0 @@
-/*
- * Copyright (C) 2019 Intel Corporation.  All rights reserved.
- * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
- */
-
-#include "bh_platform.h"
-#include <stdio.h>
-
-void bh_log_emit(const char *fmt, va_list ap)
-{
-    vprintf(fmt, ap);
-    fflush(stdout);
-}
-
-int bh_fprintf(FILE *stream, const char *fmt, ...)
-{
-    va_list ap;
-    int ret;
-
-    va_start(ap, fmt);
-    ret = vfprintf(stream ? stream : stdout, fmt, ap);
-    va_end(ap);
-
-    return ret;
-}
-
-int bh_fflush(void *stream)
-{
-    return fflush(stream ? stream : stdout);
-}

core/shared/platform/linux/bh_thread.c

@@ -1,392 +0,0 @@
-/*
- * Copyright (C) 2019 Intel Corporation.  All rights reserved.
- * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
- */
-
-#include "bh_thread.h"
-#include "bh_assert.h"
-#include "bh_log.h"
-#include <stdio.h>
-#include <stdlib.h>
-#include <sys/time.h>
-
-static bool is_thread_sys_inited = false;
-
-static korp_mutex thread_list_lock;
-static pthread_key_t thread_local_storage_key[BH_MAX_TLS_NUM];
-
-int _vm_thread_sys_init()
-{
-    unsigned i, j;
-    int ret;
-
-    if (is_thread_sys_inited)
-        return 0;
-
-    for (i = 0; i < BH_MAX_TLS_NUM; i++) {
-        ret = pthread_key_create(&thread_local_storage_key[i], NULL);
-        if (ret)
-            goto fail;
-    }
-
-    ret = vm_mutex_init(&thread_list_lock);
-    if (ret)
-        goto fail;
-
-    is_thread_sys_inited = true;
-    return 0;
-
-    fail: for (j = 0; j < i; j++)
-        pthread_key_delete(thread_local_storage_key[j]);
-    return -1;
-}
-
-void vm_thread_sys_destroy(void)
-{
-    if (is_thread_sys_inited) {
-        unsigned i;
-        for (i = 0; i < BH_MAX_TLS_NUM; i++)
-            pthread_key_delete(thread_local_storage_key[i]);
-        vm_mutex_destroy(&thread_list_lock);
-        is_thread_sys_inited = false;
-    }
-}
-
-typedef struct {
-    thread_start_routine_t start;
-    void* stack;
-    uint32 stack_size;
-    void* arg;
-} thread_wrapper_arg;
-
-static void *vm_thread_wrapper(void *arg)
-{
-    thread_wrapper_arg * targ = arg;
-    LOG_VERBOSE("THREAD CREATE 0x%08x\n", &targ);
-    targ->stack = (void *)((uintptr_t)(&arg) & (uintptr_t)~0xfff);
-    _vm_tls_put(1, targ);
-    targ->start(targ->arg);
-    BH_FREE(targ);
-    _vm_tls_put(1, NULL);
-    return NULL;
-}
-
-int _vm_thread_create_with_prio(korp_tid *tid, thread_start_routine_t start,
-                                void *arg, unsigned int stack_size, int prio)
-{
-    pthread_attr_t tattr;
-    thread_wrapper_arg *targ;
-
-    bh_assert(stack_size > 0);
-    bh_assert(tid);
-    bh_assert(start);
-
-    *tid = INVALID_THREAD_ID;
-
-    pthread_attr_init(&tattr);
-    pthread_attr_setdetachstate(&tattr, PTHREAD_CREATE_JOINABLE);
-    if (pthread_attr_setstacksize(&tattr, stack_size) != 0) {
-        bh_debug("Invalid thread stack size %u. Min stack size on Linux = %u",
-                stack_size, PTHREAD_STACK_MIN);
-        pthread_attr_destroy(&tattr);
-        return BHT_ERROR;
-    }
-
-    targ = (thread_wrapper_arg*) BH_MALLOC(sizeof(*targ));
-    if (!targ) {
-        pthread_attr_destroy(&tattr);
-        return BHT_ERROR;
-    }
-
-    targ->start = start;
-    targ->arg = arg;
-    targ->stack_size = stack_size;
-
-    if (pthread_create(tid, &tattr, vm_thread_wrapper, targ) != 0) {
-        pthread_attr_destroy(&tattr);
-        BH_FREE(targ);
-        return BHT_ERROR;
-    }
-
-    pthread_attr_destroy(&tattr);
-    return BHT_OK;
-}
-
-int _vm_thread_create(korp_tid *tid, thread_start_routine_t start, void *arg,
-                      unsigned int stack_size)
-{
-    return _vm_thread_create_with_prio(tid, start, arg, stack_size,
-                                       BH_THREAD_DEFAULT_PRIORITY);
-}
-
-korp_tid _vm_self_thread()
-{
-    return (korp_tid) pthread_self();
-}
-
-void vm_thread_exit(void * code)
-{
-    BH_FREE(_vm_tls_get(1));
-    _vm_tls_put(1, NULL);
-    pthread_exit(code);
-}
-
-void *_vm_tls_get(unsigned idx)
-{
-    bh_assert(idx < BH_MAX_TLS_NUM);
-    return pthread_getspecific(thread_local_storage_key[idx]);
-}
-
-int _vm_tls_put(unsigned idx, void * tls)
-{
-    bh_assert(idx < BH_MAX_TLS_NUM);
-    pthread_setspecific(thread_local_storage_key[idx], tls);
-    return BHT_OK;
-}
-
-int _vm_mutex_init(korp_mutex *mutex)
-{
-    return pthread_mutex_init(mutex, NULL) == 0 ? BHT_OK : BHT_ERROR;
-}
-
-int _vm_recursive_mutex_init(korp_mutex *mutex)
-{
-    int ret;
-
-    pthread_mutexattr_t mattr;
-
-    bh_assert(mutex);
-    ret = pthread_mutexattr_init(&mattr);
-    if (ret)
-        return BHT_ERROR;
-
-    pthread_mutexattr_settype(&mattr, PTHREAD_MUTEX_RECURSIVE_NP);
-    ret = pthread_mutex_init(mutex, &mattr);
-    pthread_mutexattr_destroy(&mattr);
-
-    return ret == 0 ? BHT_OK : BHT_ERROR;
-}
-
-int _vm_mutex_destroy(korp_mutex *mutex)
-{
-    int ret;
-
-    bh_assert(mutex);
-    ret = pthread_mutex_destroy(mutex);
-
-    return ret == 0 ? BHT_OK : BHT_ERROR;
-}
-
-/* Returned error (EINVAL, EAGAIN and EDEADLK) from
- locking the mutex indicates some logic error present in
- the program somewhere.
- Don't try to recover error for an existing unknown error.*/
-void vm_mutex_lock(korp_mutex *mutex)
-{
-    int ret;
-
-    bh_assert(mutex);
-    ret = pthread_mutex_lock(mutex);
-    if (0 != ret) {
-        printf("vm mutex lock failed (ret=%d)!\n", ret);
-        exit(-1);
-    }
-}
-
-int vm_mutex_trylock(korp_mutex *mutex)
-{
-    int ret;
-
-    bh_assert(mutex);
-    ret = pthread_mutex_trylock(mutex);
-
-    return ret == 0 ? BHT_OK : BHT_ERROR;
-}
-
-/* Returned error (EINVAL, EAGAIN and EPERM) from
- unlocking the mutex indicates some logic error present
- in the program somewhere.
- Don't try to recover error for an existing unknown error.*/
-void vm_mutex_unlock(korp_mutex *mutex)
-{
-    int ret;
-
-    bh_assert(mutex);
-    ret = pthread_mutex_unlock(mutex);
-    if (0 != ret) {
-        printf("vm mutex unlock failed (ret=%d)!\n", ret);
-        exit(-1);
-    }
-}
-
-int _vm_sem_init(korp_sem* sem, unsigned int c)
-{
-    int ret;
-
-    bh_assert(sem);
-    ret = sem_init(sem, 0, c);
-
-    return ret == 0 ? BHT_OK : BHT_ERROR;
-}
-
-int _vm_sem_destroy(korp_sem *sem)
-{
-    int ret;
-
-    bh_assert(sem);
-    ret = sem_destroy(sem);
-
-    return ret == 0 ? BHT_OK : BHT_ERROR;
-}
-
-int _vm_sem_wait(korp_sem *sem)
-{
-    int ret;
-
-    bh_assert(sem);
-
-    ret = sem_wait(sem);
-
-    return ret == 0 ? BHT_OK : BHT_ERROR;
-}
-
-int _vm_sem_reltimedwait(korp_sem *sem, int mills)
-{
-    int ret = BHT_OK;
-
-    struct timespec timeout;
-    const int mills_per_sec = 1000;
-    const int mills_to_nsec = 1E6;
-
-    bh_assert(sem);
-
-    if (mills == (int)BHT_WAIT_FOREVER) {
-        ret = sem_wait(sem);
-    } else {
-
-        timeout.tv_sec = mills / mills_per_sec;
-        timeout.tv_nsec = (mills % mills_per_sec) * mills_to_nsec;
-        timeout.tv_sec += time(NULL);
-
-        ret = sem_timedwait(sem, &timeout);
-    }
-
-    if (ret != BHT_OK) {
-        if (errno == BHT_TIMEDOUT) {
-            ret = BHT_TIMEDOUT;
-            errno = 0;
-        } else {
-            bh_debug("Faliure happens when timed wait is called");
-            bh_assert(0);
-        }
-    }
-
-    return ret;
-}
-
-int _vm_sem_post(korp_sem *sem)
-{
-    bh_assert(sem);
-
-    return sem_post(sem) == 0 ? BHT_OK : BHT_ERROR;
-}
-
-int _vm_cond_init(korp_cond *cond)
-{
-    bh_assert(cond);
-
-    if (pthread_cond_init(cond, NULL) != BHT_OK)
-        return BHT_ERROR;
-
-    return BHT_OK;
-}
-
-int _vm_cond_destroy(korp_cond *cond)
-{
-    bh_assert(cond);
-
-    if (pthread_cond_destroy(cond) != BHT_OK)
-        return BHT_ERROR;
-
-    return BHT_OK;
-}
-
-int _vm_cond_wait(korp_cond *cond, korp_mutex *mutex)
-{
-    bh_assert(cond);
-    bh_assert(mutex);
-
-    if (pthread_cond_wait(cond, mutex) != BHT_OK)
-        return BHT_ERROR;
-
-    return BHT_OK;
-}
-
-static void msec_nsec_to_abstime(struct timespec *ts, int64 msec, int32 nsec)
-{
-    struct timeval tv;
-
-    gettimeofday(&tv, NULL);
-
-    ts->tv_sec = (long int)(tv.tv_sec + msec / 1000);
-    ts->tv_nsec = (long int)(tv.tv_usec * 1000 + (msec % 1000) * 1000000 + nsec);
-
-    if (ts->tv_nsec >= 1000000000L) {
-        ts->tv_sec++;
-        ts->tv_nsec -= 1000000000L;
-    }
-}
-
-int _vm_cond_reltimedwait(korp_cond *cond, korp_mutex *mutex, int mills)
-{
-    int ret;
-    struct timespec abstime;
-
-    if (mills == (int)BHT_WAIT_FOREVER)
-        ret = pthread_cond_wait(cond, mutex);
-    else {
-        msec_nsec_to_abstime(&abstime, mills, 0);
-        ret = pthread_cond_timedwait(cond, mutex, &abstime);
-    }
-
-    if (ret != BHT_OK && ret != BHT_TIMEDOUT)
-        return BHT_ERROR;
-
-    return BHT_OK;
-}
-
-int _vm_cond_signal(korp_cond *cond)
-{
-    bh_assert(cond);
-
-    if (pthread_cond_signal(cond) != BHT_OK)
-        return BHT_ERROR;
-
-    return BHT_OK;
-}
-
-int _vm_cond_broadcast(korp_cond *cond)
-{
-    bh_assert(cond);
-
-    if (pthread_cond_broadcast(cond) != BHT_OK)
-        return BHT_ERROR;
-
-    return BHT_OK;
-}
-
-int _vm_thread_cancel(korp_tid thread)
-{
-    return pthread_cancel(thread);
-}
-
-int _vm_thread_join(korp_tid thread, void **value_ptr, int mills)
-{
-    return pthread_join(thread, value_ptr);
-}
-
-int _vm_thread_detach(korp_tid thread)
-{
-    return pthread_detach(thread);
-}
-

core/shared/platform/linux/bh_time.c

@@ -1,70 +0,0 @@
-/*
- * Copyright (C) 2019 Intel Corporation.  All rights reserved.
- * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
- */
-
-#include "bh_time.h"
-
-#include <unistd.h>
-#include <stdio.h>
-#include <sys/timeb.h>
-#include <time.h>
-
-/*
- * This function returns milliseconds per tick.
- * @return milliseconds per tick.
- */
-uint64 _bh_time_get_tick_millisecond()
-{
-    return (uint64)sysconf(_SC_CLK_TCK);
-}
-
-/*
- * This function returns milliseconds after boot.
- * @return milliseconds after boot.
- */
-uint64 _bh_time_get_boot_millisecond()
-{
-    struct timespec ts;
-    if (clock_gettime(CLOCK_MONOTONIC, &ts) != 0) {
-        return 0;
-    }
-
-    return ((uint64) ts.tv_sec) * 1000 + ((uint64)ts.tv_nsec) / (1000 * 1000);
-}
-
-uint32 bh_get_tick_sec()
-{
-    return (uint32)(_bh_time_get_boot_millisecond() / 1000);
-}
-
-/*
- * This function returns GMT time milliseconds since from 1970.1.1, AKA UNIX time.
- * @return milliseconds since from 1970.1.1.
- */
-uint64 _bh_time_get_millisecond_from_1970()
-{
-    struct timeb tp;
-    ftime(&tp);
-
-    return ((uint64) tp.time) * 1000 + tp.millitm
-            - (tp.dstflag == 0 ? 0 : 60 * 60 * 1000)
-            + ((uint64)tp.timezone) * 60 * 1000;
-}
-
-size_t _bh_time_strftime(char *s, size_t max, const char *format, int64 time)
-{
-    time_t time_sec = (time_t)(time / 1000);
-    struct timeb tp;
-    struct tm *ltp;
-
-    ftime(&tp);
-    time_sec -= tp.timezone * 60;
-
-    ltp = localtime(&time_sec);
-    if (ltp == NULL) {
-        return 0;
-    }
-    return strftime(s, max, format, ltp);
-}
-

core/shared/platform/linux/platform_init.c

@@ -0,0 +1,18 @@
+/*
+ * Copyright (C) 2019 Intel Corporation.  All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+ */
+
+#include "platform_api_vmcore.h"
+
+int
+bh_platform_init()
+{
+    return 0;
+}
+
+void
+bh_platform_destroy()
+{
+}
+

core/shared/platform/linux/platform_internal.h

@@ -0,0 +1,61 @@
+/*
+ * Copyright (C) 2019 Intel Corporation.  All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+ */
+
+#ifndef _PLATFORM_INTERNAL_H
+#define _PLATFORM_INTERNAL_H
+
+#include <inttypes.h>
+#include <stdbool.h>
+#include <assert.h>
+#include <time.h>
+#include <sys/time.h>
+#include <sys/timeb.h>
+#include <string.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <math.h>
+#include <stdarg.h>
+#include <ctype.h>
+#include <pthread.h>
+#include <semaphore.h>
+#include <limits.h>
+#include <fcntl.h>
+#include <unistd.h>
+#include <errno.h>
+#include <sys/socket.h>
+#include <sys/stat.h>
+#include <sys/mman.h>
+#include <netinet/in.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifndef BH_PLATFORM_LINUX
+#define BH_PLATFORM_LINUX
+#endif
+
+#define _STACK_SIZE_ADJUSTMENT (32 * 1024)
+
+/* Stack size of applet threads's native part.  */
+#define BH_APPLET_PRESERVED_STACK_SIZE (8 * 1024 + _STACK_SIZE_ADJUSTMENT)
+
+/* Default thread priority */
+#define BH_THREAD_DEFAULT_PRIORITY 0
+
+typedef pthread_t korp_tid;
+typedef pthread_mutex_t korp_mutex;
+typedef pthread_cond_t korp_cond;
+typedef pthread_t korp_thread;
+
+#define os_printf printf
+#define os_vprintf vprintf
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* end of _PLATFORM_INTERNAL_H */
+

core/shared/platform/linux/shared_platform.cmake

@@ -3,15 +3,16 @@
 
 set (PLATFORM_SHARED_DIR ${CMAKE_CURRENT_LIST_DIR})
 
+add_definitions(-DBH_PLATFORM_LINUX)
+
 include_directories(${PLATFORM_SHARED_DIR})
 include_directories(${PLATFORM_SHARED_DIR}/../include)
 
+include (${CMAKE_CURRENT_LIST_DIR}/../common/posix/platform_api_posix.cmake)
 
 file (GLOB_RECURSE source_all ${PLATFORM_SHARED_DIR}/*.c)
 
-set (PLATFORM_SHARED_SOURCE ${source_all})
-
-LIST (APPEND RUNTIME_LIB_HEADER_LIST "${PLATFORM_SHARED_DIR}/bh_platform.h")
+set (PLATFORM_SHARED_SOURCE ${source_all} ${PLATFORM_COMMON_POSIX_SOURCE})
 
 file (GLOB header ${PLATFORM_SHARED_DIR}/../include/*.h)
-LIST (APPEND RUNTIME_LIB_HEADER_LIST ${header})
+LIST (APPEND RUNTIME_LIB_HEADER_LIST ${header})

core/shared/platform/vxworks/bh_assert.c

@@ -1,58 +0,0 @@
-/*
- * Copyright (C) 2019 Intel Corporation.  All rights reserved.
- * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
- */
-
-#include "bh_platform.h"
-#include "bh_assert.h"
-#include <stdarg.h>
-#include <stdio.h>
-#include <stdlib.h>
-
-#ifdef BH_TEST
-#include <setjmp.h>
-#endif
-
-#ifdef BH_TEST
-/* for exception throwing */
-jmp_buf bh_test_jb;
-#endif
-
-void bh_assert_internal(int v, const char *file_name, int line_number,
-        const char *expr_string)
-{
-    if (v)
-        return;
-
-    if (!file_name)
-        file_name = "NULL FILENAME";
-    if (!expr_string)
-        expr_string = "NULL EXPR_STRING";
-
-    printf("\nASSERTION FAILED: %s, at FILE=%s, LINE=%d\n", expr_string,
-            file_name, line_number);
-
-#ifdef BH_TEST
-    longjmp(bh_test_jb, 1);
-#endif
-
-    abort();
-}
-
-void bh_debug_internal(const char *file_name, int line_number, const char *fmt,
-        ...)
-{
-#ifndef JEFF_TEST_VERIFIER
-    va_list args;
-
-    va_start(args, fmt);
-    bh_assert(file_name);
-
-    printf("\nDebug info FILE=%s, LINE=%d: ", file_name, line_number);
-    vprintf(fmt, args);
-
-    va_end(args);
-    printf("\n");
-#endif
-}
-

core/shared/platform/vxworks/bh_platform.c

@@ -1,186 +0,0 @@
-/*
- * Copyright (C) 2019 Intel Corporation.  All rights reserved.
- * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
- */
-
-#include "bh_platform.h"
-#include "bh_common.h"
-#include "bh_assert.h"
-
-#include <stdlib.h>
-#include <string.h>
-#include <sys/types.h>
-#include <sys/stat.h>
-#include <fcntl.h>
-#include <unistd.h>
-#include <dlfcn.h>
-#include <sys/mman.h>
-
-int
-bh_platform_init()
-{
-    return 0;
-}
-
-void *
-os_malloc(unsigned size)
-{
-    return malloc(size);
-}
-
-void *
-os_realloc(void *ptr, unsigned size)
-{
-    return realloc(ptr, size);
-}
-
-void
-os_free(void *ptr)
-{
-    free(ptr);
-}
-
-char*
-bh_read_file_to_buffer(const char *filename, uint32 *ret_size)
-{
-    char *buffer;
-    int file;
-    uint32 file_size, read_size;
-    struct stat stat_buf;
-
-    if (!filename || !ret_size) {
-        printf("Read file to buffer failed: invalid filename or ret size.\n");
-        return NULL;
-    }
-
-    if ((file = open(filename, O_RDONLY, 0)) == -1) {
-        printf("Read file to buffer failed: open file %s failed.\n",
-               filename);
-        return NULL;
-    }
-
-    if (fstat(file, &stat_buf) != 0) {
-        printf("Read file to buffer failed: fstat file %s failed.\n",
-               filename);
-        close(file);
-        return NULL;
-    }
-
-    file_size = (uint32)stat_buf.st_size;
-
-    if (!(buffer = BH_MALLOC(file_size))) {
-        printf("Read file to buffer failed: alloc memory failed.\n");
-        close(file);
-        return NULL;
-    }
-
-    read_size = (uint32)read(file, buffer, file_size);
-    close(file);
-
-    if (read_size < file_size) {
-        printf("Read file to buffer failed: read file content failed.\n");
-        BH_FREE(buffer);
-        return NULL;
-    }
-
-    *ret_size = file_size;
-    return buffer;
-}
-
-void *
-bh_mmap(void *hint, uint32 size, int prot, int flags)
-{
-    int map_prot = PROT_NONE;
-    int map_flags = MAP_ANONYMOUS | MAP_PRIVATE;
-    uint64 request_size, page_size;
-    uint8 *addr, *addr_aligned;
-    uint32 i;
-
-    /* align to 2M if no less than 2M, else align to 4K */
-    page_size = size < 2 * 1024 * 1024 ? 4096 : 2 * 1024 * 1024;
-    request_size = (size + page_size - 1) & ~(page_size - 1);
-    request_size += page_size;
-
-    if (request_size >= UINT32_MAX)
-        return NULL;
-
-    if (prot & MMAP_PROT_READ)
-        map_prot |= PROT_READ;
-
-    if (prot & MMAP_PROT_WRITE)
-        map_prot |= PROT_WRITE;
-
-    if (prot & MMAP_PROT_EXEC)
-        map_prot |= PROT_EXEC;
-
-#if defined(BUILD_TARGET_X86_64) || defined(BUILD_TARGET_AMD_64)
-    if (flags & MMAP_MAP_32BIT)
-        map_flags |= MAP_32BIT;
-#endif
-
-    if (flags & MMAP_MAP_FIXED)
-        map_flags |= MAP_FIXED;
-
-    /* try 5 times */
-    for (i = 0; i < 5; i ++) {
-        addr = mmap(hint, size, map_prot, map_flags, -1, 0);
-        if (addr != MAP_FAILED)
-            break;
-    }
-    if (addr == MAP_FAILED)
-        return NULL;
-
-    addr_aligned = (uint8*)(uintptr_t)
-        (((uint64)(uintptr_t)addr + page_size - 1) & ~(page_size - 1));
-
-    /* Unmap memory allocated before the aligned base address */
-    if (addr != addr_aligned) {
-        uint32 prefix_size = (uint32)(addr_aligned - addr);
-        munmap(addr, prefix_size);
-        request_size -= prefix_size;
-    }
-
-    /* Unmap memory allocated after the potentially unaligned end */
-    if (size != request_size) {
-        uint32 suffix_size = (uint32)(request_size - size);
-        munmap(addr_aligned + size, suffix_size);
-        request_size -= size;
-    }
-
-    if (size >= 2 * 1024 * 1024) {
-        /* Try to use huge page to improve performance */
-        if (!madvise(addr, size, MADV_HUGEPAGE))
-            /* make huge page become effective */
-            memset(addr, 0, size);
-    }
-
-    return addr_aligned;
-}
-
-void
-bh_munmap(void *addr, uint32 size)
-{
-    if (addr)
-        munmap(addr, size);
-}
-
-int
-bh_mprotect(void *addr, uint32 size, int prot)
-{
-    int map_prot = PROT_NONE;
-
-    if (!addr)
-        return 0;
-
-    if (prot & MMAP_PROT_READ)
-        map_prot |= PROT_READ;
-
-    if (prot & MMAP_PROT_WRITE)
-        map_prot |= PROT_WRITE;
-
-    if (prot & MMAP_PROT_EXEC)
-        map_prot |= PROT_EXEC;
-
-    return mprotect(addr, size, map_prot);
-}
-

core/shared/platform/vxworks/bh_platform.h

@@ -1,127 +0,0 @@
-/*
- * Copyright (C) 2019 Intel Corporation.  All rights reserved.
- * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
- */
-
-#ifndef _BH_PLATFORM_H
-#define _BH_PLATFORM_H
-
-#include "bh_config.h"
-#include "bh_types.h"
-#include <inttypes.h>
-#include <stdbool.h>
-#include <assert.h>
-#include <time.h>
-#include <string.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <math.h>
-#include <assert.h>
-#include <stdarg.h>
-#include <ctype.h>
-#include <pthread.h>
-#include <limits.h>
-#include <fcntl.h>
-#include <semaphore.h>
-#include <errno.h>
-
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-typedef uint64_t uint64;
-typedef int64_t int64;
-
-extern void DEBUGME(void);
-
-#define DIE do{bh_debug("Die here\n\n\n\n\n\n\n\n\n\n\n\n\n\n"); DEBUGME(void); while(1);}while(0)
-
-#ifndef BH_PLATFORM_VXWORKS
-#define BH_PLATFORM_VXWORKS
-#endif
-
-#define _STACK_SIZE_ADJUSTMENT (32 * 1024)
-
-/* Stack size of applet threads's native part.  */
-#define BH_APPLET_PRESERVED_STACK_SIZE      (8 * 1024 + _STACK_SIZE_ADJUSTMENT)
-
-/* Default thread priority */
-#define BH_THREAD_DEFAULT_PRIORITY 0
-
-#define BH_ROUTINE_MODIFIER
-
-#define BHT_TIMEDOUT ETIMEDOUT
-
-#define INVALID_THREAD_ID 0xFFffFFff
-
-typedef pthread_t korp_tid;
-typedef pthread_mutex_t korp_mutex;
-typedef sem_t korp_sem;
-typedef pthread_cond_t korp_cond;
-typedef pthread_t korp_thread;
-typedef void* (*thread_start_routine_t)(void*);
-
-void *os_malloc(unsigned size);
-void *os_realloc(void *ptr, unsigned size);
-void os_free(void *ptr);
-
-#define bh_printf printf
-
-int snprintf(char *buffer, size_t count, const char *format, ...);
-double fmod(double x, double y);
-float fmodf(float x, float y);
-double sqrt(double x);
-
-#define BH_WAIT_FOREVER 0xFFFFFFFF
-
-#ifndef NULL
-#  define NULL ((void*) 0)
-#endif
-
-/**
- * Return the offset of the given field in the given type.
- *
- * @param Type the type containing the filed
- * @param field the field in the type
- *
- * @return the offset of field in Type
- */
-#ifndef offsetof
-#define offsetof(Type, field) ((size_t)(&((Type *)0)->field))
-#endif
-
-#define bh_assert assert
-
-char *bh_read_file_to_buffer(const char *filename, uint32 *ret_size);
-
-int bh_platform_init();
-
-/* MMAP mode */
-enum {
-    MMAP_PROT_NONE = 0,
-    MMAP_PROT_READ = 1,
-    MMAP_PROT_WRITE = 2,
-    MMAP_PROT_EXEC = 4,
-};
-
-/* MMAP flags */
-enum {
-    MMAP_MAP_NONE = 0,
-    /* Put the mapping into 0 to 2 G, supported only on x86_64 */
-    MMAP_MAP_32BIT = 1,
-    /* Don't interpret addr as a hint: place the mapping at exactly
-       that address. */
-    MMAP_MAP_FIXED = 2
-};
-
-void *bh_mmap(void *hint, unsigned int size, int prot, int flags);
-void bh_munmap(void *addr, uint32 size);
-int bh_mprotect(void *addr, uint32 size, int prot);
-#define bh_dcache_flush() (void)0
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif

core/shared/platform/vxworks/bh_platform_log.c

@@ -1,30 +0,0 @@
-/*
- * Copyright (C) 2019 Intel Corporation.  All rights reserved.
- * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
- */
-
-#include "bh_platform.h"
-#include <stdio.h>
-
-void bh_log_emit(const char *fmt, va_list ap)
-{
-    vprintf(fmt, ap);
-    fflush(stdout);
-}
-
-int bh_fprintf(FILE *stream, const char *fmt, ...)
-{
-    va_list ap;
-    int ret;
-
-    va_start(ap, fmt);
-    ret = vfprintf(stream ? stream : stdout, fmt, ap);
-    va_end(ap);
-
-    return ret;
-}
-
-int bh_fflush(void *stream)
-{
-    return fflush(stream ? stream : stdout);
-}

core/shared/platform/vxworks/bh_thread.c

@@ -1,392 +0,0 @@
-/*
- * Copyright (C) 2019 Intel Corporation.  All rights reserved.
- * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
- */
-
-#include "bh_thread.h"
-#include "bh_assert.h"
-#include "bh_log.h"
-#include <stdio.h>
-#include <stdlib.h>
-#include <sys/time.h>
-
-static bool is_thread_sys_inited = false;
-
-static korp_mutex thread_list_lock;
-static pthread_key_t thread_local_storage_key[BH_MAX_TLS_NUM];
-
-int _vm_thread_sys_init()
-{
-    unsigned i, j;
-    int ret;
-
-    if (is_thread_sys_inited)
-        return 0;
-
-    for (i = 0; i < BH_MAX_TLS_NUM; i++) {
-        ret = pthread_key_create(&thread_local_storage_key[i], NULL);
-        if (ret)
-            goto fail;
-    }
-
-    ret = vm_mutex_init(&thread_list_lock);
-    if (ret)
-        goto fail;
-
-    is_thread_sys_inited = true;
-    return 0;
-
-    fail: for (j = 0; j < i; j++)
-        pthread_key_delete(thread_local_storage_key[j]);
-    return -1;
-}
-
-void vm_thread_sys_destroy(void)
-{
-    if (is_thread_sys_inited) {
-        unsigned i;
-        for (i = 0; i < BH_MAX_TLS_NUM; i++)
-            pthread_key_delete(thread_local_storage_key[i]);
-        vm_mutex_destroy(&thread_list_lock);
-        is_thread_sys_inited = false;
-    }
-}
-
-typedef struct {
-    thread_start_routine_t start;
-    void* stack;
-    uint32 stack_size;
-    void* arg;
-} thread_wrapper_arg;
-
-static void *vm_thread_wrapper(void *arg)
-{
-    thread_wrapper_arg * targ = arg;
-    LOG_VERBOSE("THREAD CREATE 0x%08x\n", &targ);
-    targ->stack = (void *)((uintptr_t)(&arg) & (uintptr_t)~0xfff);
-    _vm_tls_put(1, targ);
-    targ->start(targ->arg);
-    BH_FREE(targ);
-    _vm_tls_put(1, NULL);
-    return NULL;
-}
-
-int _vm_thread_create_with_prio(korp_tid *tid, thread_start_routine_t start,
-                                void *arg, unsigned int stack_size, int prio)
-{
-    pthread_attr_t tattr;
-    thread_wrapper_arg *targ;
-
-    bh_assert(stack_size > 0);
-    bh_assert(tid);
-    bh_assert(start);
-
-    *tid = INVALID_THREAD_ID;
-
-    pthread_attr_init(&tattr);
-    pthread_attr_setdetachstate(&tattr, PTHREAD_CREATE_JOINABLE);
-    if (pthread_attr_setstacksize(&tattr, stack_size) != 0) {
-        bh_debug("Invalid thread stack size %u. Min stack size on Linux = %u",
-                stack_size, PTHREAD_STACK_MIN);
-        pthread_attr_destroy(&tattr);
-        return BHT_ERROR;
-    }
-
-    targ = (thread_wrapper_arg*) BH_MALLOC(sizeof(*targ));
-    if (!targ) {
-        pthread_attr_destroy(&tattr);
-        return BHT_ERROR;
-    }
-
-    targ->start = start;
-    targ->arg = arg;
-    targ->stack_size = stack_size;
-
-    if (pthread_create(tid, &tattr, vm_thread_wrapper, targ) != 0) {
-        pthread_attr_destroy(&tattr);
-        BH_FREE(targ);
-        return BHT_ERROR;
-    }
-
-    pthread_attr_destroy(&tattr);
-    return BHT_OK;
-}
-
-int _vm_thread_create(korp_tid *tid, thread_start_routine_t start, void *arg,
-                      unsigned int stack_size)
-{
-    return _vm_thread_create_with_prio(tid, start, arg, stack_size,
-                                       BH_THREAD_DEFAULT_PRIORITY);
-}
-
-korp_tid _vm_self_thread()
-{
-    return (korp_tid) pthread_self();
-}
-
-void vm_thread_exit(void * code)
-{
-    BH_FREE(_vm_tls_get(1));
-    _vm_tls_put(1, NULL);
-    pthread_exit(code);
-}
-
-void *_vm_tls_get(unsigned idx)
-{
-    bh_assert(idx < BH_MAX_TLS_NUM);
-    return pthread_getspecific(thread_local_storage_key[idx]);
-}
-
-int _vm_tls_put(unsigned idx, void * tls)
-{
-    bh_assert(idx < BH_MAX_TLS_NUM);
-    pthread_setspecific(thread_local_storage_key[idx], tls);
-    return BHT_OK;
-}
-
-int _vm_mutex_init(korp_mutex *mutex)
-{
-    return pthread_mutex_init(mutex, NULL) == 0 ? BHT_OK : BHT_ERROR;
-}
-
-int _vm_recursive_mutex_init(korp_mutex *mutex)
-{
-    int ret;
-
-    pthread_mutexattr_t mattr;
-
-    bh_assert(mutex);
-    ret = pthread_mutexattr_init(&mattr);
-    if (ret)
-        return BHT_ERROR;
-
-    pthread_mutexattr_settype(&mattr, PTHREAD_MUTEX_RECURSIVE);
-    ret = pthread_mutex_init(mutex, &mattr);
-    pthread_mutexattr_destroy(&mattr);
-
-    return ret == 0 ? BHT_OK : BHT_ERROR;
-}
-
-int _vm_mutex_destroy(korp_mutex *mutex)
-{
-    int ret;
-
-    bh_assert(mutex);
-    ret = pthread_mutex_destroy(mutex);
-
-    return ret == 0 ? BHT_OK : BHT_ERROR;
-}
-
-/* Returned error (EINVAL, EAGAIN and EDEADLK) from
- locking the mutex indicates some logic error present in
- the program somewhere.
- Don't try to recover error for an existing unknown error.*/
-void vm_mutex_lock(korp_mutex *mutex)
-{
-    int ret;
-
-    bh_assert(mutex);
-    ret = pthread_mutex_lock(mutex);
-    if (0 != ret) {
-        printf("vm mutex lock failed (ret=%d)!\n", ret);
-        exit(-1);
-    }
-}
-
-int vm_mutex_trylock(korp_mutex *mutex)
-{
-    int ret;
-
-    bh_assert(mutex);
-    ret = pthread_mutex_trylock(mutex);
-
-    return ret == 0 ? BHT_OK : BHT_ERROR;
-}
-
-/* Returned error (EINVAL, EAGAIN and EPERM) from
- unlocking the mutex indicates some logic error present
- in the program somewhere.
- Don't try to recover error for an existing unknown error.*/
-void vm_mutex_unlock(korp_mutex *mutex)
-{
-    int ret;
-
-    bh_assert(mutex);
-    ret = pthread_mutex_unlock(mutex);
-    if (0 != ret) {
-        printf("vm mutex unlock failed (ret=%d)!\n", ret);
-        exit(-1);
-    }
-}
-
-int _vm_sem_init(korp_sem* sem, unsigned int c)
-{
-    int ret;
-
-    bh_assert(sem);
-    ret = sem_init(sem, 0, c);
-
-    return ret == 0 ? BHT_OK : BHT_ERROR;
-}
-
-int _vm_sem_destroy(korp_sem *sem)
-{
-    int ret;
-
-    bh_assert(sem);
-    ret = sem_destroy(sem);
-
-    return ret == 0 ? BHT_OK : BHT_ERROR;
-}
-
-int _vm_sem_wait(korp_sem *sem)
-{
-    int ret;
-
-    bh_assert(sem);
-
-    ret = sem_wait(sem);
-
-    return ret == 0 ? BHT_OK : BHT_ERROR;
-}
-
-int _vm_sem_reltimedwait(korp_sem *sem, int mills)
-{
-    int ret = BHT_OK;
-
-    struct timespec timeout;
-    const int mills_per_sec = 1000;
-    const int mills_to_nsec = 1E6;
-
-    bh_assert(sem);
-
-    if (mills == (int)BHT_WAIT_FOREVER) {
-        ret = sem_wait(sem);
-    } else {
-
-        timeout.tv_sec = mills / mills_per_sec;
-        timeout.tv_nsec = (mills % mills_per_sec) * mills_to_nsec;
-        timeout.tv_sec += time(NULL);
-
-        ret = sem_timedwait(sem, &timeout);
-    }
-
-    if (ret != BHT_OK) {
-        if (errno == BHT_TIMEDOUT) {
-            ret = BHT_TIMEDOUT;
-            errno = 0;
-        } else {
-            bh_debug("Faliure happens when timed wait is called");
-            bh_assert(0);
-        }
-    }
-
-    return ret;
-}
-
-int _vm_sem_post(korp_sem *sem)
-{
-    bh_assert(sem);
-
-    return sem_post(sem) == 0 ? BHT_OK : BHT_ERROR;
-}
-
-int _vm_cond_init(korp_cond *cond)
-{
-    bh_assert(cond);
-
-    if (pthread_cond_init(cond, NULL) != BHT_OK)
-        return BHT_ERROR;
-
-    return BHT_OK;
-}
-
-int _vm_cond_destroy(korp_cond *cond)
-{
-    bh_assert(cond);
-
-    if (pthread_cond_destroy(cond) != BHT_OK)
-        return BHT_ERROR;
-
-    return BHT_OK;
-}
-
-int _vm_cond_wait(korp_cond *cond, korp_mutex *mutex)
-{
-    bh_assert(cond);
-    bh_assert(mutex);
-
-    if (pthread_cond_wait(cond, mutex) != BHT_OK)
-        return BHT_ERROR;
-
-    return BHT_OK;
-}
-
-static void msec_nsec_to_abstime(struct timespec *ts, int64 msec, int32 nsec)
-{
-    struct timeval tv;
-
-    gettimeofday(&tv, NULL);
-
-    ts->tv_sec = (long int)(tv.tv_sec + msec / 1000);
-    ts->tv_nsec = (long int)(tv.tv_usec * 1000 + (msec % 1000) * 1000000 + nsec);
-
-    if (ts->tv_nsec >= 1000000000L) {
-        ts->tv_sec++;
-        ts->tv_nsec -= 1000000000L;
-    }
-}
-
-int _vm_cond_reltimedwait(korp_cond *cond, korp_mutex *mutex, int mills)
-{
-    int ret;
-    struct timespec abstime;
-
-    if (mills == (int)BHT_WAIT_FOREVER)
-        ret = pthread_cond_wait(cond, mutex);
-    else {
-        msec_nsec_to_abstime(&abstime, mills, 0);
-        ret = pthread_cond_timedwait(cond, mutex, &abstime);
-    }
-
-    if (ret != BHT_OK && ret != BHT_TIMEDOUT)
-        return BHT_ERROR;
-
-    return BHT_OK;
-}
-
-int _vm_cond_signal(korp_cond *cond)
-{
-    bh_assert(cond);
-
-    if (pthread_cond_signal(cond) != BHT_OK)
-        return BHT_ERROR;
-
-    return BHT_OK;
-}
-
-int _vm_cond_broadcast(korp_cond *cond)
-{
-    bh_assert(cond);
-
-    if (pthread_cond_broadcast(cond) != BHT_OK)
-        return BHT_ERROR;
-
-    return BHT_OK;
-}
-
-int _vm_thread_cancel(korp_tid thread)
-{
-    return pthread_cancel(thread);
-}
-
-int _vm_thread_join(korp_tid thread, void **value_ptr, int mills)
-{
-    return pthread_join(thread, value_ptr);
-}
-
-int _vm_thread_detach(korp_tid thread)
-{
-    return pthread_detach(thread);
-}
-

core/shared/platform/vxworks/bh_time.c

@@ -1,66 +0,0 @@
-/*
- * Copyright (C) 2019 Intel Corporation.  All rights reserved.
- * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
- */
-
-#include "bh_time.h"
-
-#include <unistd.h>
-#include <stdio.h>
-#include <time.h>
-
-/*
- * This function returns milliseconds per tick.
- * @return milliseconds per tick.
- */
-uint64 _bh_time_get_tick_millisecond()
-{
-    return (uint64)sysconf(_SC_CLK_TCK);
-}
-
-/*
- * This function returns milliseconds after boot.
- * @return milliseconds after boot.
- */
-uint64 _bh_time_get_boot_millisecond()
-{
-    struct timespec ts;
-    if (clock_gettime(CLOCK_MONOTONIC, &ts) != 0) {
-        return 0;
-    }
-
-    return ((uint64) ts.tv_sec) * 1000 + ((uint64)ts.tv_nsec) / (1000 * 1000);
-}
-
-uint32 bh_get_tick_sec()
-{
-    return (uint32)(_bh_time_get_boot_millisecond() / 1000);
-}
-
-/*
- * This function returns GMT time milliseconds since from 1970.1.1, AKA UNIX time.
- * @return milliseconds since from 1970.1.1.
- */
-uint64 _bh_time_get_millisecond_from_1970()
-{
-    struct timespec ts;
-
-    if (clock_gettime(CLOCK_REALTIME, &ts) != 0) {
-        return 0;
-    }
-
-    return ((uint64) ts.tv_sec) * 1000 + ((uint64)ts.tv_nsec) / (1000 * 1000);
-}
-
-size_t _bh_time_strftime(char *s, size_t max, const char *format, int64 time)
-{
-    time_t time_sec = (time_t)(time / 1000);
-    struct tm *ltp;
-
-    ltp = localtime(&time_sec);
-    if (ltp == NULL) {
-        return 0;
-    }
-    return strftime(s, max, format, ltp);
-}
-

core/shared/platform/vxworks/platform_init.c

@@ -0,0 +1,18 @@
+/*
+ * Copyright (C) 2019 Intel Corporation.  All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+ */
+
+#include "platform_api_vmcore.h"
+
+int
+bh_platform_init()
+{
+    return 0;
+}
+
+void
+bh_platform_destroy()
+{
+}
+

core/shared/platform/vxworks/platform_internal.h

@@ -0,0 +1,60 @@
+/*
+ * Copyright (C) 2019 Intel Corporation.  All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+ */
+
+#ifndef _PLATFORM_INTERNAL_H
+#define _PLATFORM_INTERNAL_H
+
+#include <inttypes.h>
+#include <stdbool.h>
+#include <assert.h>
+#include <time.h>
+#include <sys/time.h>
+#include <sys/timeb.h>
+#include <string.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <math.h>
+#include <stdarg.h>
+#include <ctype.h>
+#include <pthread.h>
+#include <semaphore.h>
+#include <limits.h>
+#include <fcntl.h>
+#include <unistd.h>
+#include <errno.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <sys/mman.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifndef BH_PLATFORM_VXWORKS
+#define BH_PLATFORM_VXWORKS
+#endif
+
+#define _STACK_SIZE_ADJUSTMENT (32 * 1024)
+
+/* Stack size of applet threads's native part.  */
+#define BH_APPLET_PRESERVED_STACK_SIZE (8 * 1024 + _STACK_SIZE_ADJUSTMENT)
+
+/* Default thread priority */
+#define BH_THREAD_DEFAULT_PRIORITY 0
+
+typedef pthread_t korp_tid;
+typedef pthread_mutex_t korp_mutex;
+typedef pthread_cond_t korp_cond;
+typedef pthread_t korp_thread;
+
+#define os_printf printf
+#define os_vprintf vprintf
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* end of _PLATFORM_INTERNAL_H */
+

core/shared/platform/vxworks/shared_platform.cmake

@@ -3,11 +3,16 @@
 
 set (PLATFORM_SHARED_DIR ${CMAKE_CURRENT_LIST_DIR})
 
+add_definitions(-DBH_PLATFORM_VXWORKS)
+
 include_directories(${PLATFORM_SHARED_DIR})
 include_directories(${PLATFORM_SHARED_DIR}/../include)
 
+include (${CMAKE_CURRENT_LIST_DIR}/../common/posix/platform_api_posix.cmake)
 
 file (GLOB_RECURSE source_all ${PLATFORM_SHARED_DIR}/*.c)
 
-set (PLATFORM_SHARED_SOURCE ${source_all})
+set (PLATFORM_SHARED_SOURCE ${source_all} ${PLATFORM_COMMON_POSIX_SOURCE})
 
+file (GLOB header ${PLATFORM_SHARED_DIR}/../include/*.h)
+LIST (APPEND RUNTIME_LIB_HEADER_LIST ${header})

core/shared/platform/zephyr/COPYRIGHT

@@ -1,126 +0,0 @@
-# $FreeBSD$
-#	@(#)COPYRIGHT	8.2 (Berkeley) 3/21/94
-
-The compilation of software known as FreeBSD is distributed under the
-following terms:
-
-Copyright (c) 1992-2019 The FreeBSD Project.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions
-are met:
-1. Redistributions of source code must retain the above copyright
-   notice, this list of conditions and the following disclaimer.
-2. Redistributions in binary form must reproduce the above copyright
-   notice, this list of conditions and the following disclaimer in the
-   documentation and/or other materials provided with the distribution.
-
-THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
-ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
-ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
-FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
-DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
-OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
-HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
-LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
-OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
-SUCH DAMAGE.
-
-The 4.4BSD and 4.4BSD-Lite software is distributed under the following
-terms:
-
-All of the documentation and software included in the 4.4BSD and 4.4BSD-Lite
-Releases is copyrighted by The Regents of the University of California.
-
-Copyright 1979, 1980, 1983, 1986, 1988, 1989, 1991, 1992, 1993, 1994
-	The Regents of the University of California.  All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions
-are met:
-1. Redistributions of source code must retain the above copyright
-   notice, this list of conditions and the following disclaimer.
-2. Redistributions in binary form must reproduce the above copyright
-   notice, this list of conditions and the following disclaimer in the
-   documentation and/or other materials provided with the distribution.
-3. All advertising materials mentioning features or use of this software
-   must display the following acknowledgement:
-This product includes software developed by the University of
-California, Berkeley and its contributors.
-4. Neither the name of the University nor the names of its contributors
-   may be used to endorse or promote products derived from this software
-   without specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
-ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
-ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
-FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
-DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
-OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
-HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
-LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
-OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
-SUCH DAMAGE.
-
-The Institute of Electrical and Electronics Engineers and the American
-National Standards Committee X3, on Information Processing Systems have
-given us permission to reprint portions of their documentation.
-
-In the following statement, the phrase ``this text'' refers to portions
-of the system documentation.
-
-Portions of this text are reprinted and reproduced in electronic form in
-the second BSD Networking Software Release, from IEEE Std 1003.1-1988, IEEE
-Standard Portable Operating System Interface for Computer Environments
-(POSIX), copyright C 1988 by the Institute of Electrical and Electronics
-Engineers, Inc.  In the event of any discrepancy between these versions
-and the original IEEE Standard, the original IEEE Standard is the referee
-document.
-
-In the following statement, the phrase ``This material'' refers to portions
-of the system documentation.
-
-This material is reproduced with permission from American National
-Standards Committee X3, on Information Processing Systems.  Computer and
-Business Equipment Manufacturers Association (CBEMA), 311 First St., NW,
-Suite 500, Washington, DC 20001-2178.  The developmental work of
-Programming Language C was completed by the X3J11 Technical Committee.
-
-The views and conclusions contained in the software and documentation are
-those of the authors and should not be interpreted as representing official
-policies, either expressed or implied, of the Regents of the University
-of California.
-
-
-NOTE: The copyright of UC Berkeley's Berkeley Software Distribution ("BSD")
-source has been updated.  The copyright addendum may be found at
-ftp://ftp.cs.berkeley.edu/pub/4bsd/README.Impt.License.Change and is
-included below.
-
-July 22, 1999
-
-To All Licensees, Distributors of Any Version of BSD:
-
-As you know, certain of the Berkeley Software Distribution ("BSD") source
-code files require that further distributions of products containing all or
-portions of the software, acknowledge within their advertising materials
-that such products contain software developed by UC Berkeley and its
-contributors.
-
-Specifically, the provision reads:
-
-"     * 3. All advertising materials mentioning features or use of this software
-      *    must display the following acknowledgement:
-      *    This product includes software developed by the University of
-      *    California, Berkeley and its contributors."
-
-Effective immediately, licensees and distributors are no longer required to
-include the acknowledgement within advertising materials.  Accordingly, the
-foregoing paragraph of those BSD Unix files containing it is hereby deleted
-in its entirety.
-
-William Hoskins
-Director, Office of Technology Licensing
-University of California, Berkeley

core/shared/platform/zephyr/bh_assert.c

@@ -1,58 +0,0 @@
-/*
- * Copyright (C) 2019 Intel Corporation.  All rights reserved.
- * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
- */
-
-#include "bh_platform.h"
-#include "bh_assert.h"
-#include <stdarg.h>
-#include <stdio.h>
-#include <stdlib.h>
-
-#ifdef BH_TEST
-#include <setjmp.h>
-#endif
-
-#ifdef BH_TEST
-/* for exception throwing */
-jmp_buf bh_test_jb;
-#endif
-extern void abort(void);
-void bh_assert_internal(int v, const char *file_name, int line_number,
-        const char *expr_string)
-{
-    if (v)
-        return;
-
-    if (!file_name)
-        file_name = "NULL FILENAME";
-    if (!expr_string)
-        expr_string = "NULL EXPR_STRING";
-
-    printk("\nASSERTION FAILED: %s, at FILE=%s, LINE=%d\n", expr_string,
-            file_name, line_number);
-
-#ifdef BH_TEST
-    longjmp(bh_test_jb, 1);
-#endif
-
-    abort();
-}
-
-void bh_debug_internal(const char *file_name, int line_number, const char *fmt,
-        ...)
-{
-#ifndef JEFF_TEST_VERIFIER
-    va_list args;
-
-    va_start(args, fmt);
-    bh_assert(file_name);
-
-    printf("\nDebug info FILE=%s, LINE=%d: ", file_name, line_number);
-    vprintf(fmt, args);
-
-    va_end(args);
-    printf("\n");
-#endif
-}
-

core/shared/platform/zephyr/bh_math.c

@@ -1,861 +0,0 @@
-/*-
- * SPDX-License-Identifier: BSD-2-Clause-FreeBSD
- *
- * Copyright (c) 2004 David Schultz <das@FreeBSD.ORG>
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- *
- * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- *
- * $FreeBSD$
- */
-
-#include "bh_platform.h"
-
-#define __FDLIBM_STDC__
-
-typedef uint32_t u_int32_t;
-typedef uint64_t u_int64_t;
-
-typedef union u32double_tag {
-    int *pint;
-    double *pdouble;
-} U32DOUBLE;
-
-static inline int *
-pdouble2pint(double *pdouble)
-{
-    U32DOUBLE u;
-    u.pdouble = pdouble;
-    return u.pint;
-}
-
-typedef union
-{
-    double value;
-    struct
-    {
-        u_int32_t lsw;
-        u_int32_t msw;
-    } parts;
-    struct
-    {
-        u_int64_t w;
-    } xparts;
-} ieee_double_shape_type_little;
-
-typedef union
-{
-    double value;
-    struct
-    {
-        u_int32_t msw;
-        u_int32_t lsw;
-    } parts;
-    struct
-    {
-        u_int64_t w;
-    } xparts;
-} ieee_double_shape_type_big;
-
-typedef union {
-    double	d;
-    struct {
-        unsigned int	manl	:32;
-        unsigned int	manh	:20;
-        unsigned int	exp	:11;
-        unsigned int	sign	:1;
-    } bits;
-} IEEEd2bits_L;
-
-typedef union {
-    double	d;
-    struct {
-        unsigned int	sign	:1;
-        unsigned int	exp	:11;
-        unsigned int	manh	:20;
-        unsigned int	manl	:32;
-    } bits;
-} IEEEd2bits_B;
-
-typedef union {
-    float   f;
-    struct {
-        unsigned int    man :23;
-        unsigned int    exp :8;
-        unsigned int    sign    :1;
-    } bits;
-} IEEEf2bits_L;
-
-typedef union {
-    float   f;
-    struct {
-        unsigned int    sign    :1;
-        unsigned int    exp :8;
-        unsigned int    man :23;
-    } bits;
-} IEEEf2bits_B;
-
-static union {
-    int a;
-    char b;
-} __ue = { .a = 1 };
-
-#define is_little_endian() (__ue.b == 1)
-
-#define __HIL(x) *(1+pdouble2pint(&x))
-#define __LOL(x) *(pdouble2pint(&x))
-#define __HIB(x) *(int*)&x
-#define __LOB(x) *(1+(int*)&x)
-
-/* Get two 32 bit ints from a double.  */
-
-#define EXTRACT_WORDS_L(ix0,ix1,d)				\
-        do {								\
-            ieee_double_shape_type_little ew_u;	                 	\
-            ew_u.value = (d);						\
-            (ix0) = ew_u.parts.msw;					\
-            (ix1) = ew_u.parts.lsw;					\
-        } while (0)
-
-/* Set a double from two 32 bit ints.  */
-
-#define INSERT_WORDS_L(d,ix0,ix1)				\
-        do {								\
-            ieee_double_shape_type_little iw_u;	                 	\
-            iw_u.parts.msw = (ix0);					\
-            iw_u.parts.lsw = (ix1);					\
-            (d) = iw_u.value;						\
-        } while (0)
-
-/* Get two 32 bit ints from a double.  */
-
-#define EXTRACT_WORDS_B(ix0,ix1,d)				\
-        do {								\
-            ieee_double_shape_type_big ew_u;	                 	\
-            ew_u.value = (d);						\
-            (ix0) = ew_u.parts.msw;					\
-            (ix1) = ew_u.parts.lsw;					\
-        } while (0)
-
-/* Set a double from two 32 bit ints.  */
-
-#define INSERT_WORDS_B(d,ix0,ix1)				\
-        do {								\
-            ieee_double_shape_type_big iw_u;	                 	\
-            iw_u.parts.msw = (ix0);					\
-            iw_u.parts.lsw = (ix1);					\
-            (d) = iw_u.value;						\
-        } while (0)
-
-/* Get the more significant 32 bit int from a double.  */
-#define GET_HIGH_WORD_L(i,d)					\
-        do {								\
-            ieee_double_shape_type_little gh_u;			        \
-            gh_u.value = (d);						\
-            (i) = gh_u.parts.msw;						\
-        } while (0)
-
-/* Get the more significant 32 bit int from a double.  */
-#define GET_HIGH_WORD_B(i,d)					\
-        do {								\
-            ieee_double_shape_type_big gh_u;			        \
-            gh_u.value = (d);						\
-            (i) = gh_u.parts.msw;						\
-        } while (0)
-
-/* Set the more significant 32 bits of a double from an int.  */
-#define SET_HIGH_WORD_L(d,v)					\
-        do {								\
-            ieee_double_shape_type_little sh_u;				\
-            sh_u.value = (d);						\
-            sh_u.parts.msw = (v);						\
-            (d) = sh_u.value;						\
-        } while (0)
-
-/* Set the more significant 32 bits of a double from an int.  */
-#define SET_HIGH_WORD_B(d,v)					\
-        do {								\
-            ieee_double_shape_type_big sh_u;				\
-            sh_u.value = (d);						\
-            sh_u.parts.msw = (v);						\
-            (d) = sh_u.value;						\
-        } while (0)
-
-/*
- * A union which permits us to convert between a float and a 32 bit
- * int.
- */
-typedef union
-{
-    float value;
-    /* FIXME: Assumes 32 bit int.  */
-    unsigned int word;
-} ieee_float_shape_type;
-
-/* Get a 32 bit int from a float.  */
-#define GET_FLOAT_WORD(i,d)                 \
-    do {                                    \
-        ieee_float_shape_type gf_u;         \
-        gf_u.value = (d);                   \
-        (i) = gf_u.word;                    \
-    } while (0)
-
-/* Set a float from a 32 bit int.  */
-#define SET_FLOAT_WORD(d,i)                 \
-    do {                                    \
-        ieee_float_shape_type sf_u;         \
-        sf_u.word = (i);                    \
-        (d) = sf_u.value;                   \
-    } while (0)
-
-/* Macro wrappers.  */
-#define EXTRACT_WORDS(ix0,ix1,d) do {   \
-    if (is_little_endian())             \
-        EXTRACT_WORDS_L(ix0,ix1,d);     \
-    else                                \
-        EXTRACT_WORDS_B(ix0,ix1,d);     \
-} while (0)
-
-#define INSERT_WORDS(d,ix0,ix1) do {    \
-    if (is_little_endian())             \
-       INSERT_WORDS_L(d,ix0,ix1);       \
-    else                                \
-        INSERT_WORDS_B(d,ix0,ix1);      \
-} while (0)
-
-#define GET_HIGH_WORD(i,d)              \
-    do {                                \
-        if (is_little_endian())         \
-        GET_HIGH_WORD_L(i,d);           \
-        else                            \
-        GET_HIGH_WORD_B(i,d);           \
-    } while (0)
-
-#define SET_HIGH_WORD(d,v)              \
-    do {                                \
-        if (is_little_endian())         \
-        SET_HIGH_WORD_L(d,v);           \
-        else                            \
-        SET_HIGH_WORD_B(d,v);           \
-    } while (0)
-
-#define __HI(x) (is_little_endian() ? __HIL(x) : __HIB(x))
-
-#define __LO(x) (is_little_endian() ? __LOL(x) : __LOB(x))
-
-/*
- * Attempt to get strict C99 semantics for assignment with non-C99 compilers.
- */
-#if FLT_EVAL_METHOD == 0 || __GNUC__ == 0
-#define	STRICT_ASSIGN(type, lval, rval)	((lval) = (rval))
-#else
-#define	STRICT_ASSIGN(type, lval, rval) do {	\
-        volatile type __lval;			\
-        \
-        if (sizeof(type) >= sizeof(long double))	\
-        (lval) = (rval);		\
-        else {					\
-            __lval = (rval);		\
-            (lval) = __lval;		\
-        }					\
-} while (0)
-#endif
-
-#ifdef __FDLIBM_STDC__
-static const double huge = 1.0e300;
-#else
-static double huge = 1.0e300;
-#endif
-
-#ifdef __STDC__
-static const double
-#else
-static double
-#endif
-tiny  = 1.0e-300;
-
-#ifdef __STDC__
-static const double
-#else
-static double
-#endif
-one=  1.00000000000000000000e+00; /* 0x3FF00000, 0x00000000 */
-
-#ifdef __STDC__
-static const double
-#else
-static double
-#endif
-TWO52[2]={
-        4.50359962737049600000e+15, /* 0x43300000, 0x00000000 */
-        -4.50359962737049600000e+15, /* 0xC3300000, 0x00000000 */
-};
-
-static double freebsd_sqrt(double x);
-static double freebsd_floor(double x);
-static double freebsd_ceil(double x);
-static double freebsd_fabs(double x);
-static double freebsd_rint(double x);
-static int freebsd_isnan(double x);
-
-static double freebsd_sqrt(double x)		/* wrapper sqrt */
-{
-    double z;
-    int32_t sign = (int)0x80000000;
-    int32_t ix0,s0,q,m,t,i;
-    u_int32_t r,t1,s1,ix1,q1;
-
-    EXTRACT_WORDS(ix0,ix1,x);
-
-    /* take care of Inf and NaN */
-    if((ix0&0x7ff00000)==0x7ff00000) {
-        return x*x+x;		/* sqrt(NaN)=NaN, sqrt(+inf)=+inf
-					   sqrt(-inf)=sNaN */
-    }
-    /* take care of zero */
-    if(ix0<=0) {
-        if(((ix0&(~sign))|ix1)==0) return x;/* sqrt(+-0) = +-0 */
-        else if(ix0<0)
-            return (x-x)/(x-x);		/* sqrt(-ve) = sNaN */
-    }
-    /* normalize x */
-    m = (ix0>>20);
-    if(m==0) {				/* subnormal x */
-        while(ix0==0) {
-            m -= 21;
-            ix0 |= (ix1>>11); ix1 <<= 21;
-        }
-        for(i=0;(ix0&0x00100000)==0;i++) ix0<<=1;
-        m -= i-1;
-        ix0 |= (ix1>>(32-i));
-        ix1 <<= i;
-    }
-    m -= 1023;	/* unbias exponent */
-    ix0 = (ix0&0x000fffff)|0x00100000;
-    if(m&1){	/* odd m, double x to make it even */
-        ix0 += ix0 + ((ix1&sign)>>31);
-        ix1 += ix1;
-    }
-    m >>= 1;	/* m = [m/2] */
-
-    /* generate sqrt(x) bit by bit */
-    ix0 += ix0 + ((ix1&sign)>>31);
-    ix1 += ix1;
-    q = q1 = s0 = s1 = 0;	/* [q,q1] = sqrt(x) */
-    r = 0x00200000;		/* r = moving bit from right to left */
-
-    while(r!=0) {
-        t = s0+r;
-        if(t<=ix0) {
-            s0   = t+r;
-            ix0 -= t;
-            q   += r;
-        }
-        ix0 += ix0 + ((ix1&sign)>>31);
-        ix1 += ix1;
-        r>>=1;
-    }
-
-    r = sign;
-    while(r!=0) {
-        t1 = s1+r;
-        t  = s0;
-        if((t<ix0)||((t==ix0)&&(t1<=ix1))) {
-            s1  = t1+r;
-            if(((t1&sign)==sign)&&(s1&sign)==0) s0 += 1;
-            ix0 -= t;
-            if (ix1 < t1) ix0 -= 1;
-            ix1 -= t1;
-            q1  += r;
-        }
-        ix0 += ix0 + ((ix1&sign)>>31);
-        ix1 += ix1;
-        r>>=1;
-    }
-
-    /* use floating add to find out rounding direction */
-    if((ix0|ix1)!=0) {
-        z = one-tiny; /* trigger inexact flag */
-        if (z>=one) {
-            z = one+tiny;
-            if (q1==(u_int32_t)0xffffffff) { q1=0; q += 1;}
-            else if (z>one) {
-                if (q1==(u_int32_t)0xfffffffe) q+=1;
-                q1+=2;
-            } else
-                q1 += (q1&1);
-        }
-    }
-    ix0 = (q>>1)+0x3fe00000;
-    ix1 =  q1>>1;
-    if ((q&1)==1) ix1 |= sign;
-    ix0 += (m <<20);
-
-    INSERT_WORDS(z,ix0,ix1);
-
-    return z;
-}
-
-static double freebsd_floor(double x)
-{
-    int32_t i0,i1,j0;
-    u_int32_t i,j;
-
-    EXTRACT_WORDS(i0,i1,x);
-
-    j0 = ((i0>>20)&0x7ff)-0x3ff;
-    if(j0<20) {
-        if(j0<0) { 	/* raise inexact if x != 0 */
-            if(huge+x>0.0) {/* return 0*sign(x) if |x|<1 */
-                if(i0>=0) {i0=i1=0;}
-                else if(((i0&0x7fffffff)|i1)!=0)
-                { i0=0xbff00000;i1=0;}
-            }
-        } else {
-            i = (0x000fffff)>>j0;
-            if(((i0&i)|i1)==0) return x; /* x is integral */
-            if(huge+x>0.0) {	/* raise inexact flag */
-                if(i0<0) i0 += (0x00100000)>>j0;
-                i0 &= (~i); i1=0;
-            }
-        }
-    } else if (j0>51) {
-        if(j0==0x400) return x+x;	/* inf or NaN */
-        else return x;		/* x is integral */
-    } else {
-        i = ((u_int32_t)(0xffffffff))>>(j0-20);
-        if((i1&i)==0) return x;	/* x is integral */
-        if(huge+x>0.0) { 		/* raise inexact flag */
-            if(i0<0) {
-                if(j0==20) i0+=1;
-                else {
-                    j = i1+(1<<(52-j0));
-                    if(j<i1) i0 +=1 ; 	/* got a carry */
-                    i1=j;
-                }
-            }
-            i1 &= (~i);
-        }
-    }
-
-    INSERT_WORDS(x,i0,i1);
-
-    return x;
-}
-
-static double freebsd_ceil(double x)
-{
-    int32_t i0,i1,j0;
-    u_int32_t i,j;
-    EXTRACT_WORDS(i0,i1,x);
-    j0 = ((i0>>20)&0x7ff)-0x3ff;
-    if(j0<20) {
-        if(j0<0) { 	/* raise inexact if x != 0 */
-            if(huge+x>0.0) {/* return 0*sign(x) if |x|<1 */
-                if(i0<0) {i0=0x80000000;i1=0;}
-                else if((i0|i1)!=0) { i0=0x3ff00000;i1=0;}
-            }
-        } else {
-            i = (0x000fffff)>>j0;
-            if(((i0&i)|i1)==0) return x; /* x is integral */
-            if(huge+x>0.0) {	/* raise inexact flag */
-                if(i0>0) i0 += (0x00100000)>>j0;
-                i0 &= (~i); i1=0;
-            }
-        }
-    } else if (j0>51) {
-        if(j0==0x400) return x+x;	/* inf or NaN */
-        else return x;		/* x is integral */
-    } else {
-        i = ((u_int32_t)(0xffffffff))>>(j0-20);
-        if((i1&i)==0) return x;	/* x is integral */
-        if(huge+x>0.0) { 		/* raise inexact flag */
-            if(i0>0) {
-                if(j0==20) i0+=1;
-                else {
-                    j = i1 + (1<<(52-j0));
-                    if(j<i1) i0+=1;	/* got a carry */
-                    i1 = j;
-                }
-            }
-            i1 &= (~i);
-        }
-    }
-    INSERT_WORDS(x,i0,i1);
-    return x;
-}
-
-static double freebsd_rint(double x)
-{
-    int32_t i0,j0,sx;
-    u_int32_t i,i1;
-    double w,t;
-    EXTRACT_WORDS(i0,i1,x);
-    sx = (i0>>31)&1;
-    j0 = ((i0>>20)&0x7ff)-0x3ff;
-    if(j0<20) {
-        if(j0<0) {
-            if(((i0&0x7fffffff)|i1)==0) return x;
-            i1 |= (i0&0x0fffff);
-            i0 &= 0xfffe0000;
-            i0 |= ((i1|-i1)>>12)&0x80000;
-            SET_HIGH_WORD(x,i0);
-            STRICT_ASSIGN(double,w,TWO52[sx]+x);
-            t =  w-TWO52[sx];
-            GET_HIGH_WORD(i0,t);
-            SET_HIGH_WORD(t,(i0&0x7fffffff)|(sx<<31));
-            return t;
-        } else {
-            i = (0x000fffff)>>j0;
-            if(((i0&i)|i1)==0) return x; /* x is integral */
-            i>>=1;
-            if(((i0&i)|i1)!=0) {
-                /*
-                 * Some bit is set after the 0.5 bit.  To avoid the
-                 * possibility of errors from double rounding in
-                 * w = TWO52[sx]+x, adjust the 0.25 bit to a lower
-                 * guard bit.  We do this for all j0<=51.  The
-                 * adjustment is trickiest for j0==18 and j0==19
-                 * since then it spans the word boundary.
-                 */
-                if(j0==19) i1 = 0x40000000; else
-                    if(j0==18) i1 = 0x80000000; else
-                        i0 = (i0&(~i))|((0x20000)>>j0);
-            }
-        }
-    } else if (j0>51) {
-        if(j0==0x400) return x+x;	/* inf or NaN */
-        else return x;		/* x is integral */
-    } else {
-        i = ((u_int32_t)(0xffffffff))>>(j0-20);
-        if((i1&i)==0) return x;	/* x is integral */
-        i>>=1;
-        if((i1&i)!=0) i1 = (i1&(~i))|((0x40000000)>>(j0-20));
-    }
-    INSERT_WORDS(x,i0,i1);
-    STRICT_ASSIGN(double,w,TWO52[sx]+x);
-    return w-TWO52[sx];
-}
-
-static int freebsd_isnan(double d)
-{
-    if (is_little_endian()) {
-        IEEEd2bits_L u;
-        u.d = d;
-        return (u.bits.exp == 2047 && (u.bits.manl != 0 || u.bits.manh != 0));
-    }
-    else {
-        IEEEd2bits_B u;
-        u.d = d;
-        return (u.bits.exp == 2047 && (u.bits.manl != 0 || u.bits.manh != 0));
-    }
-}
-
-static double freebsd_fabs(double x)
-{
-    u_int32_t high;
-    GET_HIGH_WORD(high,x);
-    SET_HIGH_WORD(x,high&0x7fffffff);
-    return x;
-}
-
-static const float huge_f = 1.0e30F;
-
-static const float
-TWO23[2]={
-    8.3886080000e+06, /* 0x4b000000 */
-    -8.3886080000e+06, /* 0xcb000000 */
-};
-
-static float
-freebsd_truncf(float x)
-{
-    int32_t i0,j0;
-    u_int32_t i;
-    GET_FLOAT_WORD(i0,x);
-    j0 = ((i0>>23)&0xff)-0x7f;
-    if(j0<23) {
-        if(j0<0) {  /* raise inexact if x != 0 */
-            if(huge_f+x>0.0F)     /* |x|<1, so return 0*sign(x) */
-                i0 &= 0x80000000;
-        } else {
-            i = (0x007fffff)>>j0;
-            if((i0&i)==0) return x; /* x is integral */
-            if(huge_f+x>0.0F)     /* raise inexact flag */
-                i0 &= (~i);
-        }
-    } else {
-        if(j0==0x80) return x+x;    /* inf or NaN */
-        else return x;      /* x is integral */
-    }
-    SET_FLOAT_WORD(x,i0);
-    return x;
-}
-
-static float
-freebsd_rintf(float x)
-{
-    int32_t i0,j0,sx;
-    float w,t;
-    GET_FLOAT_WORD(i0,x);
-    sx = (i0>>31)&1;
-    j0 = ((i0>>23)&0xff)-0x7f;
-    if(j0<23) {
-        if(j0<0) {
-            if((i0&0x7fffffff)==0) return x;
-            STRICT_ASSIGN(float,w,TWO23[sx]+x);
-            t =  w-TWO23[sx];
-            GET_FLOAT_WORD(i0,t);
-            SET_FLOAT_WORD(t,(i0&0x7fffffff)|(sx<<31));
-            return t;
-        }
-        STRICT_ASSIGN(float,w,TWO23[sx]+x);
-        return w-TWO23[sx];
-    }
-    if(j0==0x80) return x+x;    /* inf or NaN */
-    else return x;          /* x is integral */
-}
-
-static float
-freebsd_ceilf(float x)
-{
-    int32_t i0,j0;
-    u_int32_t i;
-
-    GET_FLOAT_WORD(i0,x);
-    j0 = ((i0>>23)&0xff)-0x7f;
-    if(j0<23) {
-        if(j0<0) {  /* raise inexact if x != 0 */
-            if(huge_f+x>(float)0.0) {/* return 0*sign(x) if |x|<1 */
-                if(i0<0) {i0=0x80000000;}
-                else if(i0!=0) { i0=0x3f800000;}
-            }
-        } else {
-            i = (0x007fffff)>>j0;
-            if((i0&i)==0) return x; /* x is integral */
-            if(huge_f+x>(float)0.0) { /* raise inexact flag */
-                if(i0>0) i0 += (0x00800000)>>j0;
-                i0 &= (~i);
-            }
-        }
-    } else {
-        if(j0==0x80) return x+x;    /* inf or NaN */
-        else return x;      /* x is integral */
-    }
-    SET_FLOAT_WORD(x,i0);
-    return x;
-}
-
-static float
-freebsd_floorf(float x)
-{
-    int32_t i0,j0;
-    u_int32_t i;
-    GET_FLOAT_WORD(i0,x);
-    j0 = ((i0>>23)&0xff)-0x7f;
-    if(j0<23) {
-        if(j0<0) {  /* raise inexact if x != 0 */
-            if(huge_f+x>(float)0.0) {/* return 0*sign(x) if |x|<1 */
-                if(i0>=0) {i0=0;}
-                else if((i0&0x7fffffff)!=0)
-                { i0=0xbf800000;}
-            }
-        } else {
-            i = (0x007fffff)>>j0;
-            if((i0&i)==0) return x; /* x is integral */
-            if(huge_f+x>(float)0.0) { /* raise inexact flag */
-                if(i0<0) i0 += (0x00800000)>>j0;
-                i0 &= (~i);
-            }
-        }
-    } else {
-        if(j0==0x80) return x+x;    /* inf or NaN */
-        else return x;      /* x is integral */
-    }
-    SET_FLOAT_WORD(x,i0);
-    return x;
-}
-
-static float
-freebsd_fminf(float x, float y)
-{
-    if (is_little_endian()) {
-        IEEEf2bits_L u[2];
-
-        u[0].f = x;
-        u[1].f = y;
-
-        /* Check for NaNs to avoid raising spurious exceptions. */
-        if (u[0].bits.exp == 255 && u[0].bits.man != 0)
-            return (y);
-        if (u[1].bits.exp == 255 && u[1].bits.man != 0)
-            return (x);
-
-        /* Handle comparisons of signed zeroes. */
-        if (u[0].bits.sign != u[1].bits.sign)
-            return (u[u[1].bits.sign].f);
-    }
-    else {
-        IEEEf2bits_B u[2];
-
-        u[0].f = x;
-        u[1].f = y;
-
-        /* Check for NaNs to avoid raising spurious exceptions. */
-        if (u[0].bits.exp == 255 && u[0].bits.man != 0)
-            return (y);
-        if (u[1].bits.exp == 255 && u[1].bits.man != 0)
-            return (x);
-
-        /* Handle comparisons of signed zeroes. */
-        if (u[0].bits.sign != u[1].bits.sign)
-            return (u[u[1].bits.sign].f);
-    }
-
-    return (x < y ? x : y);
-}
-
-static float
-freebsd_fmaxf(float x, float y)
-{
-    if (is_little_endian()) {
-        IEEEf2bits_L u[2];
-
-        u[0].f = x;
-        u[1].f = y;
-
-        /* Check for NaNs to avoid raising spurious exceptions. */
-        if (u[0].bits.exp == 255 && u[0].bits.man != 0)
-            return (y);
-        if (u[1].bits.exp == 255 && u[1].bits.man != 0)
-            return (x);
-
-        /* Handle comparisons of signed zeroes. */
-        if (u[0].bits.sign != u[1].bits.sign)
-            return (u[u[0].bits.sign].f);
-    }
-    else {
-        IEEEf2bits_B u[2];
-
-        u[0].f = x;
-        u[1].f = y;
-
-        /* Check for NaNs to avoid raising spurious exceptions. */
-        if (u[0].bits.exp == 255 && u[0].bits.man != 0)
-            return (y);
-        if (u[1].bits.exp == 255 && u[1].bits.man != 0)
-            return (x);
-
-        /* Handle comparisons of signed zeroes. */
-        if (u[0].bits.sign != u[1].bits.sign)
-            return (u[u[0].bits.sign].f);
-    }
-
-    return (x > y ? x : y);
-}
-
-double sqrt(double x)
-{
-    return freebsd_sqrt(x);
-}
-
-double floor(double x)
-{
-    return freebsd_floor(x);
-}
-
-double ceil(double x)
-{
-    return freebsd_ceil(x);
-}
-
-double fmin(double x, double y)
-{
-    return x < y ? x : y;
-}
-
-double fmax(double x, double y)
-{
-    return x > y ? x : y;
-}
-
-double rint(double x)
-{
-    return freebsd_rint(x);
-}
-
-double fabs(double x)
-{
-    return freebsd_fabs(x);
-}
-
-int isnan(double x)
-{
-    return freebsd_isnan(x);
-}
-
-double trunc(double x)
-{
-    return (x > 0) ? freebsd_floor(x) : freebsd_ceil(x);
-}
-
-int signbit(double x)
-{
-    return ((__HI(x) & 0x80000000) >> 31);
-}
-
-float
-truncf(float x)
-{
-    return freebsd_truncf(x);
-}
-
-float
-rintf(float x)
-{
-    return freebsd_rintf(x);
-}
-
-float
-ceilf(float x)
-{
-    return freebsd_ceilf(x);
-}
-
-float
-floorf(float x)
-{
-    return freebsd_floorf(x);
-}
-
-float
-fminf(float x, float y)
-{
-    return freebsd_fminf(x, y);
-}
-
-float
-fmaxf(float x, float y)
-{
-    return freebsd_fmaxf(x, y);
-}
-

core/shared/platform/zephyr/bh_platform.h

@@ -1,149 +0,0 @@
-/*
- * Copyright (C) 2019 Intel Corporation.  All rights reserved.
- * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
- */
-
-#ifndef _BH_PLATFORM_H
-#define _BH_PLATFORM_H
-
-#include "bh_config.h"
-#include "bh_types.h"
-#include <autoconf.h>
-#include <zephyr.h>
-#include <kernel.h>
-#include <sys/printk.h>
-#include <inttypes.h>
-#include <stdarg.h>
-#include <ctype.h>
-#include <limits.h>
-#include <errno.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include <strings.h>
-#ifndef CONFIG_NET_BUF_USER_DATA_SIZE
-#define CONFIG_NET_BUF_USER_DATA_SIZE 0
-#endif
-#include <net/net_pkt.h>
-#include <net/net_if.h>
-#include <net/net_ip.h>
-#include <net/net_core.h>
-#include <net/net_context.h>
-
-#ifndef BH_PLATFORM_ZEPHYR
-#define BH_PLATFORM_ZEPHYR
-#endif
-
-#define BH_APPLET_PRESERVED_STACK_SIZE (2 * BH_KB)
-
-/* Default thread priority */
-#define BH_THREAD_DEFAULT_PRIORITY 7
-
-#define BH_ROUTINE_MODIFIER
-
-/* Invalid thread tid */
-#define INVALID_THREAD_ID NULL
-
-#define BH_WAIT_FOREVER K_FOREVER
-
-typedef uint64_t uint64;
-typedef int64_t int64;
-
-typedef struct k_thread korp_thread;
-typedef korp_thread *korp_tid;
-typedef struct k_mutex korp_mutex;
-typedef struct k_sem korp_sem;
-
-struct bh_thread_wait_node;
-typedef struct bh_thread_wait_node *bh_thread_wait_list;
-typedef struct korp_cond {
-    struct k_mutex wait_list_lock;
-    bh_thread_wait_list thread_wait_list;
-} korp_cond;
-
-typedef void* (*thread_start_routine_t)(void*);
-
-void *os_malloc(unsigned size);
-void *os_realloc(void *ptr, unsigned size);
-void os_free(void *ptr);
-
-#define bh_printf printf
-
-/* Unit test framework is based on C++, where the declaration of
- snprintf is different.  */
-#ifndef __cplusplus
-int snprintf(char *buffer, size_t count, const char *format, ...);
-#endif
-
-#ifndef NULL
-#define NULL ((void*)0)
-#endif
-
-/**
- * Return the offset of the given field in the given type.
- *
- * @param Type the type containing the filed
- * @param field the field in the type
- *
- * @return the offset of field in Type
- */
-#ifndef offsetof
-#define offsetof(Type, field) ((size_t)(&((Type *)0)->field))
-#endif
-
-#define bh_assert(x) \
-    do { \
-        if (!(x)) { \
-            printk("bh_assert(%s, %d)\n", __func__, __LINE__);\
-        } \
-    } while (0)
-
-/* math functions */
-double sqrt(double x);
-double floor(double x);
-double ceil(double x);
-double fmin(double x, double y);
-double fmax(double x, double y);
-double rint(double x);
-double fabs(double x);
-double trunc(double x);
-float floorf(float x);
-float ceilf(float x);
-float fminf(float x, float y);
-float fmaxf(float x, float y);
-float rintf(float x);
-float truncf(float x);
-int signbit(double x);
-int isnan(double x);
-
-unsigned long long int strtoull(const char *nptr, char **endptr,
-                                int base);
-double strtod(const char *nptr, char **endptr);
-float strtof(const char *nptr, char **endptr);
-
-int bh_platform_init();
-
-/* MMAP mode */
-enum {
-    MMAP_PROT_NONE = 0,
-    MMAP_PROT_READ = 1,
-    MMAP_PROT_WRITE = 2,
-    MMAP_PROT_EXEC = 4
-};
-
-/* MMAP flags */
-enum {
-    MMAP_MAP_NONE = 0,
-    /* Put the mapping into 0 to 2 G, supported only on x86_64 */
-    MMAP_MAP_32BIT = 1,
-    /* Don't interpret addr as a hint: place the mapping at exactly
-       that address. */
-    MMAP_MAP_FIXED = 2
-};
-
-void *bh_mmap(void *hint, unsigned int size, int prot, int flags);
-void bh_munmap(void *addr, uint32 size);
-int bh_mprotect(void *addr, uint32 size, int prot);
-void bh_dcache_flush();
-
-#endif

core/shared/platform/zephyr/bh_platform_log.c

@@ -1,57 +0,0 @@
-/*
- * Copyright (C) 2019 Intel Corporation.  All rights reserved.
- * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
- */
-
-#include "bh_platform.h"
-#include <stdio.h>
-
-struct out_context {
-    int count;
-};
-
-typedef int (*out_func_t)(int c, void *ctx);
-
-extern void *__printk_get_hook(void);
-static int (*_char_out)(int) = NULL;
-
-static int char_out(int c, struct out_context *ctx)
-{
-    ctx->count++;
-    if (_char_out == NULL) {
-        _char_out = __printk_get_hook();
-    }
-    return _char_out(c);
-}
-
-static int bh_vprintk(const char *fmt, va_list ap)
-{
-    struct out_context ctx = { 0 };
-    z_vprintk((out_func_t) char_out, &ctx, fmt, ap);
-    return ctx.count;
-}
-
-void bh_log_emit(const char *fmt, va_list ap)
-{
-    bh_vprintk(fmt, ap);
-}
-
-int bh_fprintf(FILE *stream, const char *fmt, ...)
-{
-    (void) stream;
-    va_list ap;
-    int ret;
-
-    va_start(ap, fmt);
-    ret = bh_vprintk(fmt, ap);
-    va_end(ap);
-
-    return ret;
-}
-
-int bh_fflush(void *stream)
-{
-    (void) stream;
-    return 0;
-}
-

core/shared/platform/zephyr/bh_time.c

@@ -1,46 +0,0 @@
-/*
- * Copyright (C) 2019 Intel Corporation.  All rights reserved.
- * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
- */
-
-#include "bh_time.h"
-
-/*
- * This function returns milliseconds per tick.
- * @return milliseconds per tick.
- */
-uint64 _bh_time_get_tick_millisecond()
-{
-    return k_uptime_get_32();
-}
-
-/*
- * This function returns milliseconds after boot.
- * @return milliseconds after boot.
- */
-uint64 _bh_time_get_boot_millisecond()
-{
-    return k_uptime_get_32();
-}
-
-uint64 _bh_time_get_millisecond_from_1970()
-{
-    return k_uptime_get();
-}
-
-size_t _bh_time_strftime(char *str, size_t max, const char *format, int64 time)
-{
-    (void) format;
-    (void) time;
-    uint32 t = k_uptime_get_32();
-    int h, m, s;
-
-    t = t % (24 * 60 * 60);
-    h = t / (60 * 60);
-    t = t % (60 * 60);
-    m = t / 60;
-    s = t % 60;
-
-    return snprintf(str, max, "%02d:%02d:%02d", h, m, s);
-}
-

core/shared/platform/zephyr/platform_internal.h

@@ -0,0 +1,80 @@
+/*
+ * Copyright (C) 2019 Intel Corporation.  All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+ */
+
+#ifndef _PLATFORM_INTERNAL_H
+#define _PLATFORM_INTERNAL_H
+
+#include <autoconf.h>
+#include <zephyr.h>
+#include <kernel.h>
+#include <sys/printk.h>
+#include <inttypes.h>
+#include <stdarg.h>
+#include <ctype.h>
+#include <limits.h>
+#include <errno.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <strings.h>
+#ifndef CONFIG_NET_BUF_USER_DATA_SIZE
+#define CONFIG_NET_BUF_USER_DATA_SIZE 0
+#endif
+#include <net/net_pkt.h>
+#include <net/net_if.h>
+#include <net/net_ip.h>
+#include <net/net_core.h>
+#include <net/net_context.h>
+
+#ifdef CONFIG_ARM_MPU
+#include <arch/arm/aarch32/cortex_m/cmsis.h>
+#endif
+
+
+#ifndef BH_PLATFORM_ZEPHYR
+#define BH_PLATFORM_ZEPHYR
+#endif
+
+#define BH_APPLET_PRESERVED_STACK_SIZE (2 * BH_KB)
+
+/* Default thread priority */
+#define BH_THREAD_DEFAULT_PRIORITY 7
+
+typedef struct k_thread korp_thread;
+typedef korp_thread *korp_tid;
+typedef struct k_mutex korp_mutex;
+
+struct os_thread_wait_node;
+typedef struct os_thread_wait_node *os_thread_wait_list;
+typedef struct korp_cond {
+    struct k_mutex wait_list_lock;
+    os_thread_wait_list thread_wait_list;
+} korp_cond;
+
+#define os_printf printf
+
+/* math functions which are not provided by os */
+double sqrt(double x);
+double floor(double x);
+double ceil(double x);
+double fmin(double x, double y);
+double fmax(double x, double y);
+double rint(double x);
+double fabs(double x);
+double trunc(double x);
+float floorf(float x);
+float ceilf(float x);
+float fminf(float x, float y);
+float fmaxf(float x, float y);
+float rintf(float x);
+float truncf(float x);
+int signbit(double x);
+int isnan(double x);
+
+unsigned long long int strtoull(const char *nptr, char **endptr, int base);
+double strtod(const char *nptr, char **endptr);
+float strtof(const char *nptr, char **endptr);
+
+#endif

core/shared/platform/zephyr/shared_platform.cmake

@@ -1,13 +1,16 @@
-# Copyright (C) 2019 Intel Corporation.  All rights reserved.
-# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-
-set (PLATFORM_SHARED_DIR ${CMAKE_CURRENT_LIST_DIR})
-
-include_directories(${PLATFORM_SHARED_DIR})
-include_directories(${PLATFORM_SHARED_DIR}/../include)
-
-
-file (GLOB_RECURSE source_all ${PLATFORM_SHARED_DIR}/*.c)
-
-set (PLATFORM_SHARED_SOURCE ${source_all})
-
+# Copyright (C) 2019 Intel Corporation.  All rights reserved.
+# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+set (PLATFORM_SHARED_DIR ${CMAKE_CURRENT_LIST_DIR})
+
+add_definitions(-DBH_PLATFORM_ZEPHYR)
+
+include_directories(${PLATFORM_SHARED_DIR})
+include_directories(${PLATFORM_SHARED_DIR}/../include)
+
+include (${CMAKE_CURRENT_LIST_DIR}/../common/math/platform_api_math.cmake)
+
+file (GLOB_RECURSE source_all ${PLATFORM_SHARED_DIR}/*.c)
+
+set (PLATFORM_SHARED_SOURCE ${source_all} ${PLATFORM_COMMON_MATH_SOURCE})
+

core/shared/platform/zephyr/zephyr_platform.c

@@ -3,14 +3,10 @@
  * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
  */
 
-#include "bh_platform.h"
-#include "bh_common.h"
-#include <stdlib.h>
-#include <string.h>
-#ifdef CONFIG_ARM_MPU
-#include <arch/arm/aarch32/cortex_m/cmsis.h>
-#endif
+#include "platform_api_vmcore.h"
+#include "platform_api_extension.h"
 
+#if WASM_ENABLE_AOT != 0
 #ifdef CONFIG_ARM_MPU
 /**
  * This function will allow execute from sram region.
@@ -32,6 +28,7 @@ disable_mpu_rasr_xn(void)
 
 }
 #endif  /* end of CONFIG_ARM_MPU */
+#endif
 
 static int
 _stdout_hook_iwasm(int c)
@@ -40,6 +37,12 @@ _stdout_hook_iwasm(int c)
     return 1;
 }
 
+int
+os_thread_sys_init();
+
+void
+os_thread_sys_destroy();
+
 int
 bh_platform_init()
 {
@@ -54,7 +57,13 @@ bh_platform_init()
 #endif
 #endif
 
-    return 0;
+    return os_thread_sys_init();
+}
+
+void
+bh_platform_destroy()
+{
+    os_thread_sys_destroy();
 }
 
 void *
@@ -74,26 +83,48 @@ os_free(void *ptr)
 {
 }
 
+struct out_context {
+    int count;
+};
+
+typedef int (*out_func_t)(int c, void *ctx);
+
+static int
+char_out(int c, void *ctx)
+{
+    struct out_context *out_ctx = (struct out_context*)ctx;
+    out_ctx->count++;
+    return _stdout_hook_iwasm(c);
+}
+
+int
+os_vprintf(const char *fmt, va_list ap)
+{
+    struct out_context ctx = { 0 };
+    z_vprintk(char_out, &ctx, fmt, ap);
+    return ctx.count;
+}
+
 void *
-bh_mmap(void *hint, unsigned int size, int prot, int flags)
+os_mmap(void *hint, unsigned int size, int prot, int flags)
 {
     return BH_MALLOC(size);
 }
 
 void
-bh_munmap(void *addr, uint32 size)
+os_munmap(void *addr, uint32 size)
 {
     return BH_FREE(addr);
 }
 
 int
-bh_mprotect(void *addr, uint32 size, int prot)
+os_mprotect(void *addr, uint32 size, int prot)
 {
     return 0;
 }
 
 void
-bh_dcache_flush()
+os_dcache_flush()
 {
 #if defined(CONFIG_CPU_CORTEX_M7) && defined(CONFIG_ARM_MPU)
     uint32 key;

core/shared/platform/zephyr/zephyr_thread.c

@@ -3,18 +3,29 @@
  * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
  */
 
-#include "bh_thread.h"
-#include "bh_assert.h"
-#include "bh_log.h"
+#include "platform_api_vmcore.h"
+#include "platform_api_extension.h"
 
-typedef struct bh_thread_wait_node {
+#define bh_assert(v) do {                                   \
+    if (!(v)) {                                             \
+        int _count;                                         \
+        printf("\nASSERTION FAILED: %s, at %s, line %d\n",  \
+               #v, __FILE__, __LINE__);                     \
+        _count = printf(" ");                               \
+        /* divived by 0 to make it abort */                 \
+        printf("%d\n", _count / (_count - 1));              \
+        while (1);                                          \
+    }                                                       \
+  } while (0)
+
+typedef struct os_thread_wait_node {
     struct k_sem sem;
-    bh_thread_wait_list next;
-} bh_thread_wait_node;
+    os_thread_wait_list next;
+} os_thread_wait_node;
 
-typedef struct bh_thread_data {
+typedef struct os_thread_data {
     /* Next thread data */
-    struct bh_thread_data *next;
+    struct os_thread_data *next;
     /* Zephyr thread handle */
     korp_tid tid;
     /* Jeff thread local root */
@@ -22,46 +33,46 @@ typedef struct bh_thread_data {
     /* Lock for waiting list */
     struct k_mutex wait_list_lock;
     /* Waiting list of other threads who are joining this thread */
-    bh_thread_wait_list thread_wait_list;
+    os_thread_wait_list thread_wait_list;
     /* Thread stack size */
     unsigned stack_size;
     /* Thread stack */
     char stack[1];
-} bh_thread_data;
+} os_thread_data;
 
-typedef struct bh_thread_obj {
+typedef struct os_thread_obj {
     struct k_thread thread;
     /* Whether the thread is terminated and this thread object is to
      be freed in the future. */
     bool to_be_freed;
-    struct bh_thread_obj *next;
-} bh_thread_obj;
+    struct os_thread_obj *next;
+} os_thread_obj;
 
 static bool is_thread_sys_inited = false;
 
 /* Thread data of supervisor thread */
-static bh_thread_data supervisor_thread_data;
+static os_thread_data supervisor_thread_data;
 
 /* Lock for thread data list */
 static struct k_mutex thread_data_lock;
 
 /* Thread data list */
-static bh_thread_data *thread_data_list = NULL;
+static os_thread_data *thread_data_list = NULL;
 
 /* Lock for thread object list */
 static struct k_mutex thread_obj_lock;
 
 /* Thread object list */
-static bh_thread_obj *thread_obj_list = NULL;
+static os_thread_obj *thread_obj_list = NULL;
 
-static void thread_data_list_add(bh_thread_data *thread_data)
+static void thread_data_list_add(os_thread_data *thread_data)
 {
     k_mutex_lock(&thread_data_lock, K_FOREVER);
     if (!thread_data_list)
         thread_data_list = thread_data;
     else {
         /* If already in list, just return */
-        bh_thread_data *p = thread_data_list;
+        os_thread_data *p = thread_data_list;
         while (p) {
             if (p == thread_data) {
                 k_mutex_unlock(&thread_data_lock);
@@ -77,7 +88,7 @@ static void thread_data_list_add(bh_thread_data *thread_data)
     k_mutex_unlock(&thread_data_lock);
 }
 
-static void thread_data_list_remove(bh_thread_data *thread_data)
+static void thread_data_list_remove(os_thread_data *thread_data)
 {
     k_mutex_lock(&thread_data_lock, K_FOREVER);
     if (thread_data_list) {
@@ -85,7 +96,7 @@ static void thread_data_list_remove(bh_thread_data *thread_data)
             thread_data_list = thread_data_list->next;
         else {
             /* Search and remove it from list */
-            bh_thread_data *p = thread_data_list;
+            os_thread_data *p = thread_data_list;
             while (p && p->next != thread_data)
                 p = p->next;
             if (p && p->next == thread_data)
@@ -95,12 +106,12 @@ static void thread_data_list_remove(bh_thread_data *thread_data)
     k_mutex_unlock(&thread_data_lock);
 }
 
-static bh_thread_data *
+static os_thread_data *
 thread_data_list_lookup(k_tid_t tid)
 {
     k_mutex_lock(&thread_data_lock, K_FOREVER);
     if (thread_data_list) {
-        bh_thread_data *p = thread_data_list;
+        os_thread_data *p = thread_data_list;
         while (p) {
             if (p->tid == tid) {
                 /* Found */
@@ -114,7 +125,7 @@ thread_data_list_lookup(k_tid_t tid)
     return NULL;
 }
 
-static void thread_obj_list_add(bh_thread_obj *thread_obj)
+static void thread_obj_list_add(os_thread_obj *thread_obj)
 {
     k_mutex_lock(&thread_obj_lock, K_FOREVER);
     if (!thread_obj_list)
@@ -129,7 +140,7 @@ static void thread_obj_list_add(bh_thread_obj *thread_obj)
 
 static void thread_obj_list_reclaim()
 {
-    bh_thread_obj *p, *p_prev;
+    os_thread_obj *p, *p_prev;
     k_mutex_lock(&thread_obj_lock, K_FOREVER);
     p_prev = NULL;
     p = thread_obj_list;
@@ -152,7 +163,7 @@ static void thread_obj_list_reclaim()
     k_mutex_unlock(&thread_obj_lock);
 }
 
-int _vm_thread_sys_init()
+int os_thread_sys_init()
 {
     if (is_thread_sys_inited)
         return BHT_OK;
@@ -170,31 +181,31 @@ int _vm_thread_sys_init()
     return BHT_OK;
 }
 
-void vm_thread_sys_destroy(void)
+void os_thread_sys_destroy(void)
 {
     if (is_thread_sys_inited) {
         is_thread_sys_inited = false;
     }
 }
 
-static bh_thread_data *
+static os_thread_data *
 thread_data_current()
 {
     k_tid_t tid = k_current_get();
     return thread_data_list_lookup(tid);
 }
 
-static void vm_thread_cleanup(void)
+static void os_thread_cleanup(void)
 {
-    bh_thread_data *thread_data = thread_data_current();
+    os_thread_data *thread_data = thread_data_current();
 
     bh_assert(thread_data != NULL);
     k_mutex_lock(&thread_data->wait_list_lock, K_FOREVER);
     if (thread_data->thread_wait_list) {
         /* Signal each joining thread */
-        bh_thread_wait_list head = thread_data->thread_wait_list;
+        os_thread_wait_list head = thread_data->thread_wait_list;
         while (head) {
-            bh_thread_wait_list next = head->next;
+            os_thread_wait_list next = head->next;
             k_sem_give(&head->sem);
             /* head will be freed by joining thread */
             head = next;
@@ -206,32 +217,32 @@ static void vm_thread_cleanup(void)
     thread_data_list_remove(thread_data);
     /* Set flag to true for the next thread creating to
      free the thread object */
-    ((bh_thread_obj*) thread_data->tid)->to_be_freed = true;
+    ((os_thread_obj*) thread_data->tid)->to_be_freed = true;
     BH_FREE(thread_data);
 }
 
-static void vm_thread_wrapper(void *start, void *arg, void *thread_data)
+static void os_thread_wrapper(void *start, void *arg, void *thread_data)
 {
     /* Set thread custom data */
-    ((bh_thread_data*) thread_data)->tid = k_current_get();
+    ((os_thread_data*) thread_data)->tid = k_current_get();
     thread_data_list_add(thread_data);
 
     ((thread_start_routine_t) start)(arg);
-    vm_thread_cleanup();
+    os_thread_cleanup();
 }
 
-int _vm_thread_create(korp_tid *p_tid, thread_start_routine_t start, void *arg,
-        unsigned int stack_size)
+int os_thread_create(korp_tid *p_tid, thread_start_routine_t start, void *arg,
+                     unsigned int stack_size)
 {
-    return _vm_thread_create_with_prio(p_tid, start, arg, stack_size,
+    return os_thread_create_with_prio(p_tid, start, arg, stack_size,
     BH_THREAD_DEFAULT_PRIORITY);
 }
 
-int _vm_thread_create_with_prio(korp_tid *p_tid, thread_start_routine_t start,
-        void *arg, unsigned int stack_size, int prio)
+int os_thread_create_with_prio(korp_tid *p_tid, thread_start_routine_t start,
+                               void *arg, unsigned int stack_size, int prio)
 {
     korp_tid tid;
-    bh_thread_data *thread_data;
+    os_thread_data *thread_data;
     unsigned thread_data_size;
 
     if (!p_tid || !stack_size)
@@ -241,13 +252,13 @@ int _vm_thread_create_with_prio(korp_tid *p_tid, thread_start_routine_t start,
     thread_obj_list_reclaim();
 
     /* Create and initialize thread object */
-    if (!(tid = BH_MALLOC(sizeof(bh_thread_obj))))
+    if (!(tid = BH_MALLOC(sizeof(os_thread_obj))))
         return BHT_ERROR;
 
-    memset(tid, 0, sizeof(bh_thread_obj));
+    memset(tid, 0, sizeof(os_thread_obj));
 
     /* Create and initialize thread data */
-    thread_data_size = offsetof(bh_thread_data, stack) + stack_size;
+    thread_data_size = offsetof(os_thread_data, stack) + stack_size;
     if (!(thread_data = BH_MALLOC(thread_data_size))) {
         BH_FREE(tid);
         return BHT_ERROR;
@@ -260,7 +271,7 @@ int _vm_thread_create_with_prio(korp_tid *p_tid, thread_start_routine_t start,
 
     /* Create the thread */
     if (!((tid = k_thread_create(tid, (k_thread_stack_t *) thread_data->stack,
-            stack_size, vm_thread_wrapper, start, arg, thread_data, prio, 0,
+            stack_size, os_thread_wrapper, start, arg, thread_data, prio, 0,
             K_NO_WAIT)))) {
         BH_FREE(tid);
         BH_FREE(thread_data);
@@ -271,38 +282,24 @@ int _vm_thread_create_with_prio(korp_tid *p_tid, thread_start_routine_t start,
 
     /* Set thread custom data */
     thread_data_list_add(thread_data);
-    thread_obj_list_add((bh_thread_obj*) tid);
+    thread_obj_list_add((os_thread_obj*) tid);
     *p_tid = tid;
     return BHT_OK;
 }
 
-korp_tid _vm_self_thread()
+korp_tid os_self_thread()
 {
     return (korp_tid) k_current_get();
 }
 
-void vm_thread_exit(void * code)
-{
-    (void) code;
-    korp_tid self = vm_self_thread();
-    vm_thread_cleanup();
-    k_thread_abort((k_tid_t) self);
-}
-
-int _vm_thread_cancel(korp_tid thread)
-{
-    k_thread_abort((k_tid_t) thread);
-    return 0;
-}
-
-int _vm_thread_join(korp_tid thread, void **value_ptr, int mills)
+int os_thread_join(korp_tid thread, void **value_ptr)
 {
     (void) value_ptr;
-    bh_thread_data *thread_data;
-    bh_thread_wait_node *node;
+    os_thread_data *thread_data;
+    os_thread_wait_node *node;
 
     /* Create wait node and append it to wait list */
-    if (!(node = BH_MALLOC(sizeof(bh_thread_wait_node))))
+    if (!(node = BH_MALLOC(sizeof(os_thread_wait_node))))
         return BHT_ERROR;
 
     k_sem_init(&node->sem, 0, 1);
@@ -317,7 +314,7 @@ int _vm_thread_join(korp_tid thread, void **value_ptr, int mills)
         thread_data->thread_wait_list = node;
     else {
         /* Add to end of waiting list */
-        bh_thread_wait_node *p = thread_data->thread_wait_list;
+        os_thread_wait_node *p = thread_data->thread_wait_list;
         while (p->next)
             p = p->next;
         p->next = node;
@@ -325,7 +322,7 @@ int _vm_thread_join(korp_tid thread, void **value_ptr, int mills)
     k_mutex_unlock(&thread_data->wait_list_lock);
 
     /* Wait the sem */
-    k_sem_take(&node->sem, mills);
+    k_sem_take(&node->sem, K_FOREVER);
 
     /* Wait some time for the thread to be actually terminated */
     k_sleep(100);
@@ -335,118 +332,54 @@ int _vm_thread_join(korp_tid thread, void **value_ptr, int mills)
     return BHT_OK;
 }
 
-int _vm_thread_detach(korp_tid thread)
-{
-    (void) thread;
-    return BHT_OK;
-}
-
-void *_vm_tls_get(unsigned idx)
-{
-    (void) idx;
-    bh_thread_data *thread_data;
-
-    bh_assert(idx == 0);
-    thread_data = thread_data_current();
-
-    return thread_data ? thread_data->tlr : NULL;
-}
-
-int _vm_tls_put(unsigned idx, void * tls)
-{
-    bh_thread_data *thread_data;
-
-    (void) idx;
-    bh_assert(idx == 0);
-    thread_data = thread_data_current();
-    bh_assert(thread_data != NULL);
-
-    thread_data->tlr = tls;
-    return BHT_OK;
-}
-
-int _vm_mutex_init(korp_mutex *mutex)
-{
-    (void) mutex;
-    k_mutex_init(mutex);
-    return BHT_OK;
-}
-
-int _vm_recursive_mutex_init(korp_mutex *mutex)
+int os_mutex_init(korp_mutex *mutex)
 {
     k_mutex_init(mutex);
     return BHT_OK;
 }
 
-int _vm_mutex_destroy(korp_mutex *mutex)
+int os_recursive_mutex_init(korp_mutex *mutex)
+{
+    k_mutex_init(mutex);
+    return BHT_OK;
+}
+
+int os_mutex_destroy(korp_mutex *mutex)
 {
     (void) mutex;
     return BHT_OK;
 }
 
-void vm_mutex_lock(korp_mutex *mutex)
+void os_mutex_lock(korp_mutex *mutex)
 {
     k_mutex_lock(mutex, K_FOREVER);
 }
 
-int vm_mutex_trylock(korp_mutex *mutex)
-{
-    return k_mutex_lock(mutex, K_NO_WAIT);
-}
-
-void vm_mutex_unlock(korp_mutex *mutex)
+void os_mutex_unlock(korp_mutex *mutex)
 {
     k_mutex_unlock(mutex);
 }
 
-int _vm_sem_init(korp_sem* sem, unsigned int c)
-{
-    int ret = k_sem_init(sem, 0, c);
-    return ret == 0 ? BHT_OK : BHT_ERROR;
-}
-
-int _vm_sem_destroy(korp_sem *sem)
-{
-    (void) sem;
-    return BHT_OK;
-}
-
-int _vm_sem_wait(korp_sem *sem)
-{
-    return k_sem_take(sem, K_FOREVER);
-}
-
-int _vm_sem_reltimedwait(korp_sem *sem, int mills)
-{
-    return k_sem_take(sem, mills);
-}
-
-int _vm_sem_post(korp_sem *sem)
-{
-    k_sem_give(sem);
-    return BHT_OK;
-}
-
-int _vm_cond_init(korp_cond *cond)
+int os_cond_init(korp_cond *cond)
 {
     k_mutex_init(&cond->wait_list_lock);
     cond->thread_wait_list = NULL;
     return BHT_OK;
 }
 
-int _vm_cond_destroy(korp_cond *cond)
+int os_cond_destroy(korp_cond *cond)
 {
     (void) cond;
     return BHT_OK;
 }
 
-static int _vm_cond_wait_internal(korp_cond *cond, korp_mutex *mutex,
-        bool timed, int mills)
+static int os_cond_wait_internal(korp_cond *cond, korp_mutex *mutex,
+                                 bool timed, int mills)
 {
-    bh_thread_wait_node *node;
+    os_thread_wait_node *node;
 
     /* Create wait node and append it to wait list */
-    if (!(node = BH_MALLOC(sizeof(bh_thread_wait_node))))
+    if (!(node = BH_MALLOC(sizeof(os_thread_wait_node))))
         return BHT_ERROR;
 
     k_sem_init(&node->sem, 0, 1);
@@ -457,7 +390,7 @@ static int _vm_cond_wait_internal(korp_cond *cond, korp_mutex *mutex,
         cond->thread_wait_list = node;
     else {
         /* Add to end of wait list */
-        bh_thread_wait_node *p = cond->thread_wait_list;
+        os_thread_wait_node *p = cond->thread_wait_list;
         while (p->next)
             p = p->next;
         p->next = node;
@@ -475,7 +408,7 @@ static int _vm_cond_wait_internal(korp_cond *cond, korp_mutex *mutex,
         cond->thread_wait_list = node->next;
     else {
         /* Remove from the wait list */
-        bh_thread_wait_node *p = cond->thread_wait_list;
+        os_thread_wait_node *p = cond->thread_wait_list;
         while (p->next != node)
             p = p->next;
         p->next = node->next;
@@ -486,17 +419,21 @@ static int _vm_cond_wait_internal(korp_cond *cond, korp_mutex *mutex,
     return BHT_OK;
 }
 
-int _vm_cond_wait(korp_cond *cond, korp_mutex *mutex)
+int os_cond_wait(korp_cond *cond, korp_mutex *mutex)
 {
-    return _vm_cond_wait_internal(cond, mutex, false, 0);
+    return os_cond_wait_internal(cond, mutex, false, 0);
 }
 
-int _vm_cond_reltimedwait(korp_cond *cond, korp_mutex *mutex, int mills)
+int os_cond_reltimedwait(korp_cond *cond, korp_mutex *mutex, int useconds)
 {
-    return _vm_cond_wait_internal(cond, mutex, true, mills);
+
+    if (useconds == BHT_WAIT_FOREVER)
+        return os_cond_wait_internal(cond, mutex, false, 0);
+    else
+        return os_cond_wait_internal(cond, mutex, true, useconds / 1000);
 }
 
-int _vm_cond_signal(korp_cond *cond)
+int os_cond_signal(korp_cond *cond)
 {
     /* Signal the head wait node of wait list */
     k_mutex_lock(&cond->wait_list_lock, K_FOREVER);
@@ -507,19 +444,3 @@ int _vm_cond_signal(korp_cond *cond)
     return BHT_OK;
 }
 
-int _vm_cond_broadcast(korp_cond *cond)
-{
-    /* Signal each wait node of wait list */
-    k_mutex_lock(&cond->wait_list_lock, K_FOREVER);
-    if (cond->thread_wait_list) {
-        bh_thread_wait_node *p = cond->thread_wait_list;
-        while (p) {
-            k_sem_give(&p->sem);
-            p = p->next;
-        }
-    }
-    k_mutex_unlock(&cond->wait_list_lock);
-
-    return BHT_OK;
-}
-

core/shared/platform/zephyr/zephyr_time.c

@@ -0,0 +1,13 @@
+/*
+ * Copyright (C) 2019 Intel Corporation.  All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+ */
+
+#include "platform_api_vmcore.h"
+
+uint64
+os_time_get_boot_microsecond()
+{
+    return k_uptime_get_32() * 1000;
+}
+