Add the clGetKernelArgInfo api and misc help functions

Signed-off-by: Junyan He <junyan.he@linux.intel.com>
Reviewed-by: Zhigang Gong <zhigang.gong@linux.intel.com>

5 files changed, 122 insertions, 0 deletions

diff --git a/src/cl_api.c b/src/cl_api.c
index 44ddaf05..25b5870f 100644
--- a/src/cl_api.c
+++ b/src/cl_api.c
@@ -1219,6 +1219,33 @@ error:
   return err;
 }
 
+cl_int clGetKernelArgInfo(cl_kernel kernel, cl_uint arg_index, cl_kernel_arg_info param_name,
+        size_t param_value_size, void *param_value, size_t *param_value_size_ret)
+{
+  cl_int err = CL_SUCCESS;
+  CHECK_KERNEL(kernel);
+
+  if (param_name != CL_KERNEL_ARG_ADDRESS_QUALIFIER
+          && param_name != CL_KERNEL_ARG_ACCESS_QUALIFIER
+          && param_name != CL_KERNEL_ARG_TYPE_NAME
+          && param_name != CL_KERNEL_ARG_TYPE_QUALIFIER
+          && param_name != CL_KERNEL_ARG_NAME) {
+    err = CL_INVALID_VALUE;
+    goto error;
+  }
+
+  if (arg_index >= kernel->arg_n) {
+    err = CL_INVALID_ARG_INDEX;
+    goto error;
+  }
+
+  err = cl_get_kernel_arg_info(kernel, arg_index, param_name, param_value_size,
+          param_value, param_value_size_ret);
+
+error:
+  return err;
+}
+
 cl_int
 clGetKernelInfo(cl_kernel        kernel,
                 cl_kernel_info   param_name,
diff --git a/src/cl_gbe_loader.cpp b/src/cl_gbe_loader.cpp
index c374561b..54dbe842 100644
--- a/src/cl_gbe_loader.cpp
+++ b/src/cl_gbe_loader.cpp
@@ -68,6 +68,7 @@ gbe_dup_printfset_cb* interp_dup_printfset = NULL;
 gbe_get_printf_sizeof_size_cb* interp_get_printf_sizeof_size = NULL;
 gbe_release_printf_info_cb* interp_release_printf_info = NULL;
 gbe_output_printf_cb* interp_output_printf = NULL;
+gbe_kernel_get_arg_info_cb *interp_kernel_get_arg_info = NULL;
 
 struct GbeLoaderInitializer
 {
@@ -229,6 +230,10 @@ struct GbeLoaderInitializer
     if (interp_output_printf == NULL)
       return false;
 
+    interp_kernel_get_arg_info = *(gbe_kernel_get_arg_info_cb**)dlsym(dlhInterp, "gbe_kernel_get_arg_info");
+    if (interp_kernel_get_arg_info == NULL)
+      return false;
+
     return true;
   }
 
diff --git a/src/cl_gbe_loader.h b/src/cl_gbe_loader.h
index 65b96fe3..0e1d0a00 100644
--- a/src/cl_gbe_loader.h
+++ b/src/cl_gbe_loader.h
@@ -68,6 +68,7 @@ extern gbe_program_compile_from_source_cb *compiler_program_compile_from_source;
 extern gbe_program_new_gen_program_cb *compiler_program_new_gen_program;
 extern gbe_program_link_program_cb *compiler_program_link_program;
 extern gbe_program_build_from_llvm_cb *compiler_program_build_from_llvm;
+extern gbe_kernel_get_arg_info_cb *interp_kernel_get_arg_info;
 
 int CompilerSupported();
 #ifdef __cplusplus
diff --git a/src/cl_kernel.c b/src/cl_kernel.c
index 5fc3e44f..64ffd5f4 100644
--- a/src/cl_kernel.c
+++ b/src/cl_kernel.c
@@ -208,6 +208,89 @@ cl_kernel_set_arg(cl_kernel k, cl_uint index, size_t sz, const void *value)
   return CL_SUCCESS;
 }
 
+LOCAL int
+cl_get_kernel_arg_info(cl_kernel k, cl_uint arg_index, cl_kernel_arg_info param_name,
+                       size_t param_value_size, void *param_value, size_t *param_value_size_ret)
+{
+  assert(k != NULL);
+  void *ret_info = interp_kernel_get_arg_info(k->opaque, arg_index,
+                           param_name - CL_KERNEL_ARG_ADDRESS_QUALIFIER);
+  int str_len = 0;
+  cl_kernel_arg_type_qualifier type_qual = CL_KERNEL_ARG_TYPE_NONE;
+
+  switch (param_name) {
+  case CL_KERNEL_ARG_ADDRESS_QUALIFIER:
+    if (param_value_size < sizeof(cl_kernel_arg_address_qualifier))
+      return CL_INVALID_VALUE;
+    if (param_value_size_ret)
+      *param_value_size_ret = sizeof(cl_kernel_arg_address_qualifier);
+    if (!param_value) return CL_SUCCESS;
+    if ((ulong)ret_info == 0) {
+      *(cl_kernel_arg_address_qualifier *)param_value = CL_KERNEL_ARG_ADDRESS_PRIVATE;
+    } else if ((ulong)ret_info == 1) {
+      *(cl_kernel_arg_address_qualifier *)param_value = CL_KERNEL_ARG_ADDRESS_GLOBAL;
+    } else if ((ulong)ret_info == 2) {
+      *(cl_kernel_arg_address_qualifier *)param_value = CL_KERNEL_ARG_ADDRESS_CONSTANT;
+    } else if ((ulong)ret_info == 3) {
+      *(cl_kernel_arg_address_qualifier *)param_value = CL_KERNEL_ARG_ADDRESS_LOCAL;
+    } else {
+      /* If no address qualifier is specified, the default address qualifier
+         which is CL_KERNEL_ARG_ADDRESS_PRIVATE is returned. */
+      *(cl_kernel_arg_address_qualifier *)param_value = CL_KERNEL_ARG_ADDRESS_LOCAL;
+    }
+    return CL_SUCCESS;
+
+  case CL_KERNEL_ARG_ACCESS_QUALIFIER:
+    if (param_value_size < sizeof(cl_kernel_arg_access_qualifier))
+      return CL_INVALID_VALUE;
+    if (param_value_size_ret)
+      *param_value_size_ret = sizeof(cl_kernel_arg_access_qualifier);
+    if (!param_value) return CL_SUCCESS;
+    if (!strcmp((char*)ret_info, "write_only")) {
+      *(cl_kernel_arg_address_qualifier *)param_value = CL_KERNEL_ARG_ACCESS_WRITE_ONLY;
+    } else if (!strcmp((char*)ret_info, "read_only")) {
+      *(cl_kernel_arg_address_qualifier *)param_value = CL_KERNEL_ARG_ACCESS_READ_ONLY;
+    } else if (!strcmp((char*)ret_info, "read_write")) {
+      *(cl_kernel_arg_address_qualifier *)param_value = CL_KERNEL_ARG_ACCESS_READ_WRITE;
+    } else {
+      *(cl_kernel_arg_address_qualifier *)param_value = CL_KERNEL_ARG_ACCESS_NONE;
+    }
+    return CL_SUCCESS;
+
+  case CL_KERNEL_ARG_TYPE_NAME:
+  case CL_KERNEL_ARG_NAME:
+    str_len = strlen(ret_info);
+    if (param_value_size < str_len + 1)
+      return CL_INVALID_VALUE;
+    if (param_value_size_ret)
+      *param_value_size_ret = str_len + 1;
+    if (!param_value) return CL_SUCCESS;
+    memcpy(param_value, ret_info, str_len);
+    ((char *)param_value)[str_len] = 0;
+    return CL_SUCCESS;
+
+  case CL_KERNEL_ARG_TYPE_QUALIFIER:
+    if (param_value_size < sizeof(cl_kernel_arg_type_qualifier))
+      return CL_INVALID_VALUE;
+    if (param_value_size_ret)
+      *param_value_size_ret = sizeof(cl_kernel_arg_type_qualifier);
+    if (!param_value) return CL_SUCCESS;
+    if (strstr((char*)ret_info, "const"))
+      type_qual = type_qual | CL_KERNEL_ARG_TYPE_CONST;
+    if (strstr((char*)ret_info, "volatile"))
+      type_qual = type_qual | CL_KERNEL_ARG_TYPE_VOLATILE;
+    if (strstr((char*)ret_info, "restrict"))
+      type_qual = type_qual | CL_KERNEL_ARG_TYPE_RESTRICT;
+    *(cl_kernel_arg_type_qualifier *)param_value = type_qual;
+    return CL_SUCCESS;
+
+  default:
+    assert(0);
+  }
+
+  return CL_SUCCESS;
+}
+
 LOCAL uint32_t
 cl_kernel_get_simd_width(cl_kernel k)
 {
diff --git a/src/cl_kernel.h b/src/cl_kernel.h
index 8d0e5666..09362b3b 100644
--- a/src/cl_kernel.h
+++ b/src/cl_kernel.h
@@ -93,6 +93,12 @@ extern int cl_kernel_set_arg(cl_kernel,
                              size_t      arg_size,
                              const void *arg_value);
 
+/* Get the argument information */
+extern int cl_get_kernel_arg_info(cl_kernel k, cl_uint arg_index,
+                                  cl_kernel_arg_info param_name,
+                                  size_t param_value_size, void *param_value,
+                                  size_t *param_value_size_ret);
+
 /* Compute and check the work group size from the user provided local size */
 extern cl_int
 cl_kernel_work_group_sz(cl_kernel ker,