[OPENMP] Support for simple FORTRAN print by implementing Fortran Runtime on the device using hostexec. Only 4 RT functions implemented on this initial commit. It is easy to add more Fortran Runtime functions as they are encountered with different test cases. Currently I know print* works with strings and integers. Comment which Fortran Runtime functions we need by trying things and seeing what unresolved references the compiler generates

Change-Id: Ic70e82510c09c05ccfaa51dab1a996903754276a

Author: gregrodgers

offload/hostexec/CMakeLists.txt

@@ -66,6 +66,7 @@ endif()
 
    add_compile_options($<$<OR:$<COMPILE_LANGUAGE:C>,$<COMPILE_LANGUAGE:CXX>>:-UNDEBUG>)
    set_property(TARGET amdgcn_hostexec_services PROPERTY POSITION_INDEPENDENT_CODE ON)
+   target_link_libraries(amdgcn_hostexec_services FortranRuntime -L${CMAKE_BINARY_DIR}/../../lib  -L${CMAKE_INSTALL_PREFIX}/lib)
 
 if (LIBOMPTARGET_DEP_CUDA_FOUND)
    list(APPEND HOSTRPC_ARCHS "nvptx")
@@ -126,6 +127,7 @@ set(hostexec_stubs_filename ${CMAKE_CURRENT_SOURCE_DIR}/src/hostexec_stubs.cpp)
 set(h_file           ${CMAKE_CURRENT_SOURCE_DIR}/src/hostexec.h)
 set(internal_h_file  ${CMAKE_CURRENT_SOURCE_DIR}/src/hostexec_internal.h)
 
+
 foreach(archname ${HOSTRPC_ARCHS})
    if (${archname} STREQUAL "amdgcn")
       set(triple "amdgcn-amd-amdhsa")

offload/hostexec/services/execute_service.cpp

@@ -184,9 +184,15 @@ static void handler_SERVICE_FREE(uint32_t device_id, uint64_t *payload) {
 
 static bool trace_init = false;
 static bool host_exec_trace;
-static char* TrcStrs[HOSTEXEC_SID_VOID+1] = {"unsed", "terminate", "device_malloc",
-        "host_malloc", "free", "printf", "fprintf", "ftnassign", "sanatizer",
-        "uint", "uint64", "double", "int", "long", "float" , "void"};
+#define _CCHAR (const char *)
+static const char *TrcStrs[HOSTEXEC_SID_VOID + 1] = {
+    _CCHAR "unsed",       _CCHAR "terminate", _CCHAR "device_malloc",
+    _CCHAR "host_malloc", _CCHAR "free",      _CCHAR "printf",
+    _CCHAR "fprintf",     _CCHAR "ftnassign", _CCHAR "sanatizer",
+    _CCHAR "uint",        _CCHAR "uint64",    _CCHAR "double",
+    _CCHAR "int",         _CCHAR "long",      _CCHAR "float",
+    _CCHAR "void"};
+#undef _CCAR
 // The consumer thread will serialize each active lane and call execute_service
 // for the service request. These services are intended to be architecturally
 // independent.
@@ -926,6 +932,43 @@ static service_rc hostrpc_call_fnptr(uint32_t NumArgs, void *fnptr,
   return _RC_SUCCESS;
 }
 
+extern "C" {
+
+extern void *V_FortranAioBeginExternalListOutput(void *fnptr, ...) {
+  va_list args;
+  va_start(args, fnptr);
+  uint32_t v0 = va_arg(args, uint32_t);
+  char *v1 = va_arg(args, char *);
+  uint32_t v2 = va_arg(args, uint32_t);
+  va_end(args);
+  return _FortranAioBeginExternalListOutput(v0, v1, v2);
+}
+extern bool V_FortranAioOutputAscii(void *fnptr, ...) {
+  va_list args;
+  va_start(args, fnptr);
+  void *v0 = va_arg(args, void *);
+  char *v1 = va_arg(args, char *);
+  uint64_t v2 = va_arg(args, uint64_t);
+  va_end(args);
+  return _FortranAioOutputAscii(v0, v1, v2);
+}
+extern bool V_FortranAioOutputInteger32(void *fnptr, ...) {
+  va_list args;
+  va_start(args, fnptr);
+  void *v0 = va_arg(args, void *);
+  uint32_t v1 = va_arg(args, uint32_t);
+  va_end(args);
+  return _FortranAioOutputInteger32(v0, v1);
+}
+extern uint32_t V_FortranAioEndIoStatement(void *fnptr, ...) {
+  va_list args;
+  va_start(args, fnptr);
+  void *v0 = va_arg(args, void *);
+  va_end(args);
+  return _FortranAioEndIoStatement(v0);
+}
+}
+
 template <typename T, typename FT>
 static service_rc hostexec_service(char *buf, size_t bufsz, T *return_value) {
   if (bufsz == 0)
@@ -959,6 +1002,24 @@ static service_rc hostexec_service(char *buf, size_t bufsz, T *return_value) {
                                 &data_not_used, a) != _RC_SUCCESS)
     return _RC_ERROR_INVALID_REQUEST;
 
+  uint64_t DeviceRuntime_idx = (uint64_t)fnptr;
+  switch (DeviceRuntime_idx) {
+  case _FortranAioBeginExternalListOutput_idx:
+    fnptr = (void *)V_FortranAioBeginExternalListOutput;
+    break;
+  case _FortranAioOutputAscii_idx:
+    fnptr = (void *)V_FortranAioOutputAscii;
+    break;
+  case _FortranAioOutputInteger32_idx:
+    fnptr = (void *)V_FortranAioOutputInteger32;
+    break;
+  case _FortranAioEndIoStatement_idx:
+    fnptr = (void *)V_FortranAioEndIoStatement;
+    break;
+  case _FortranAio_INVALID:
+  default:
+    break;
+  }
   if (hostrpc_call_fnptr<T, FT>(NumArgs, fnptr, a, return_value) != _RC_SUCCESS)
     return _RC_ERROR_INVALID_REQUEST;
 

offload/hostexec/src/hostexec_internal.h

@@ -109,4 +109,20 @@ enum hostexec_sid {
   HOSTEXEC_SID_VOID,
 };
 
+enum KnownDeviceRuntime_idx {
+  _FortranAio_INVALID,
+  _FortranAioBeginExternalListOutput_idx,
+  _FortranAioOutputAscii_idx,
+  _FortranAioOutputInteger32_idx,
+  _FortranAioEndIoStatement_idx
+};
+
+extern "C" {
+extern void *_FortranAioBeginExternalListOutput(uint32_t a1, char *a2,
+                                                uint32_t a3);
+extern bool _FortranAioOutputAscii(void *a1, char *a2, uint64_t a3);
+extern bool _FortranAioOutputInteger32(void *a1, uint32_t a2);
+extern uint32_t _FortranAioEndIoStatement(void *a1);
+} // end of extern "C"
+
 #endif // __HOSTEXEC_INTERNAL_H__

offload/hostexec/src/hostexec_stubs.cpp

@@ -233,6 +233,51 @@ uint32_t __strlen_max(char *instr, uint32_t maxstrlen) {
   return maxstrlen;
 }
 
-} // end extern "C"
+#if defined(__NVPTX__) || defined(__AMDGCN__)
+// These are the function definitions of known device runtime functions
+// that will be executed on the host using hostexec. The host functions
+// that implement the service are defined in services/execute_service.cpp.
+// These functions begin with V_ because they are variadic functions.
+// Variadic functions make it easy to reconstruct the exact arguments for
+// the call to the actual host runtime function.
+
+// Since these variadic functions are static functions in execute_service.cpp,
+// we only send the index from the enum set of known functions as a fake
+// function pointer in the first arg. See the switch(DeviceRuntime_idx) in
+// execute_service.cpp which determins the correct function pointer to
+// the V_ function based on this index.
+//
+// If you get an unresolved reference at device link time, then you have an
+// unimplemented device runtime function. To implement a new function, take
+// these steps.
+// 1.  Find or build the c++ interface to this function and put the declare in
+//     hostexec_internal.h. Add an new value to the enum KnownDeviceRuntime_idx.
+// 2.  Add the definition of the device function below with the same interface.
+//     The definition should call the hostexec_<RT> with the proper return type
+//     Use c-style typecasting if the return type you need does not have a
+//     corresponding hostexec function.
+// 3.  Add a new V_ function in execute_service.cpp and the new case in the
+//     switch(DeviceRuntime_idx).
 
+void *_FortranAioBeginExternalListOutput(uint32_t a1, char *a2, uint32_t a3) {
+  void *enum2ptr = (void *)_FortranAioBeginExternalListOutput_idx;
+  return (void *)hostexec_uint64(enum2ptr, a1, a2, a3);
+}
+bool _FortranAioOutputAscii(void *a1, char *a2, uint64_t a3) {
+  // Must terminate the print string because it gets sent to host.
+  a2[a3 - 1] = (char)0;
+  void *enum2ptr = (void *)_FortranAioOutputAscii_idx;
+  return (bool)hostexec_uint(enum2ptr, a1, a2, a3);
+}
+bool _FortranAioOutputInteger32(void *a1, uint32_t a2) {
+  void *enum2ptr = (void *)_FortranAioOutputInteger32_idx;
+  return (bool)hostexec_uint(enum2ptr, a1, a2);
+}
+uint32_t _FortranAioEndIoStatement(void *a1) {
+  void *enum2ptr = (void *)_FortranAioEndIoStatement_idx;
+  return (uint32_t)hostexec_uint(enum2ptr, a1);
+}
+#endif
+
+} // end extern "C"
 #pragma omp end declare target