Add the offload directory which contains the code needed to support

OpenMP 4.0 "target" directives. This will need more work for
generality, but we want to get it out and visible to the community.

llvm-svn: 205909

1 files changed, 170 insertions, 0 deletions

diff --git a/openmp/offload/src/offload_common.cpp b/openmp/offload/src/offload_common.cpp
new file mode 100644
index 00000000000..3681b066bc4
--- /dev/null
+++ b/openmp/offload/src/offload_common.cpp
@@ -0,0 +1,170 @@
+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.txt for details.
+//
+//===----------------------------------------------------------------------===//
+
+
+#if defined(LINUX) || defined(FREEBSD)
+#include <mm_malloc.h>
+#endif
+
+#include "offload_common.h"
+
+// The debug routines
+
+#if OFFLOAD_DEBUG > 0
+
+void __dump_bytes(
+    int trace_level,
+    const void *data,
+    int len
+)
+{
+    if (console_enabled > trace_level) {
+        const uint8_t *arr = (const uint8_t*) data;
+        char buffer[4096];
+        char *bufferp;
+        int count = 0;
+
+        bufferp = buffer;
+        while (len--) {
+            sprintf(bufferp, "%02x", *arr++);
+            bufferp += 2;
+            count++;
+            if ((count&3) == 0) {
+                sprintf(bufferp, " ");
+                bufferp++;
+            }
+            if ((count&63) == 0) {
+                OFFLOAD_DEBUG_TRACE(trace_level, "%s\n", buffer);
+                bufferp = buffer;
+                count = 0;
+            }
+        }
+        if (count) {
+            OFFLOAD_DEBUG_TRACE(trace_level, "%s\n", buffer);
+        }
+    }
+}
+#endif // OFFLOAD_DEBUG
+
+// The Marshaller and associated routines
+
+void Marshaller::send_data(
+    const void *data,
+    int64_t length
+)
+{
+    OFFLOAD_DEBUG_TRACE(2, "send_data(%p, %lld)\n",
+                        data, length);
+    memcpy(buffer_ptr, data, (size_t)length);
+    buffer_ptr += length;
+    tfr_size += length;
+}
+
+void Marshaller::receive_data(
+    void *data,
+    int64_t length
+)
+{
+    OFFLOAD_DEBUG_TRACE(2, "receive_data(%p, %lld)\n",
+                        data, length);
+    memcpy(data, buffer_ptr, (size_t)length);
+    buffer_ptr += length;
+    tfr_size += length;
+}
+
+// Send function pointer
+void Marshaller::send_func_ptr(
+    const void* data
+)
+{
+    const char* name;
+    size_t      length;
+
+    if (data != 0) {
+        name = __offload_funcs.find_name(data);
+        if (name == 0) {
+#if OFFLOAD_DEBUG > 0
+            if (console_enabled > 2) {
+                __offload_funcs.dump();
+            }
+#endif // OFFLOAD_DEBUG > 0
+
+            LIBOFFLOAD_ERROR(c_send_func_ptr, data);
+            exit(1);
+        }
+        length = strlen(name) + 1;
+    }
+    else {
+        name = "";
+        length = 1;
+    }
+
+    memcpy(buffer_ptr, name, length);
+    buffer_ptr += length;
+    tfr_size += length;
+}
+
+// Receive function pointer
+void Marshaller::receive_func_ptr(
+    const void** data
+)
+{
+    const char* name;
+    size_t      length;
+
+    name = (const char*) buffer_ptr;
+    if (name[0] != '\0') {
+        *data = __offload_funcs.find_addr(name);
+        if (*data == 0) {
+#if OFFLOAD_DEBUG > 0
+            if (console_enabled > 2) {
+                __offload_funcs.dump();
+            }
+#endif // OFFLOAD_DEBUG > 0
+
+            LIBOFFLOAD_ERROR(c_receive_func_ptr, name);
+            exit(1);
+        }
+        length = strlen(name) + 1;
+    }
+    else {
+        *data = 0;
+        length = 1;
+    }
+
+    buffer_ptr += length;
+    tfr_size += length;
+}
+
+// End of the Marshaller and associated routines
+
+extern void *OFFLOAD_MALLOC(
+    size_t size,
+    size_t align
+)
+{
+    void *ptr;
+    int   err;
+
+    OFFLOAD_DEBUG_TRACE(2, "%s(%lld, %lld)\n", __func__, size, align);
+
+    if (align < sizeof(void*)) {
+        align = sizeof(void*);
+    }
+
+    ptr = _mm_malloc(size, align);
+    if (ptr == NULL) {
+        LIBOFFLOAD_ERROR(c_offload_malloc, size, align);
+        exit(1);
+    }
+
+    OFFLOAD_DEBUG_TRACE(2, "%s returned %p\n", __func__, ptr);
+
+    return ptr;
+}