diff --git a/loader/icd.c b/loader/icd.c
index e50b27a2..fd17f5c7 100644
--- a/loader/icd.c
+++ b/loader/icd.c
@@ -59,8 +59,8 @@ void khrIcdVendorAdd(const char *libraryName)
     pfn_clGetExtensionFunctionAddress p_clGetExtensionFunctionAddress = NULL;
     pfn_clIcdGetPlatformIDs p_clIcdGetPlatformIDs = NULL;
 #if KHR_LOADER_MANAGED_DISPATCH
-    clGetFunctionAddressForPlatformKHR_fn p_clGetFunctionAddressForPlatform = NULL;
-    clSetPlatformDispatchDataKHR_fn p_clSetPlatformDispatchData = NULL;
+    clIcdGetFunctionAddressForPlatformKHR_fn p_clIcdGetFunctionAddressForPlatform = NULL;
+    clIcdSetPlatformDispatchDataKHR_fn p_clIcdSetPlatformDispatchData = NULL;
 #endif
     cl_uint i = 0;
     cl_uint platformCount = 0;
@@ -109,9 +109,9 @@ void khrIcdVendorAdd(const char *libraryName)
     }
 
 #if KHR_LOADER_MANAGED_DISPATCH
-    // try to get clGetFunctionAddressForPlatformKHR and clSetPlatformDispatchDataKHR to detect cl_khr_icd2 support
-    p_clGetFunctionAddressForPlatform = (clGetFunctionAddressForPlatformKHR_fn)(size_t)p_clGetExtensionFunctionAddress("clGetFunctionAddressForPlatformKHR");
-    p_clSetPlatformDispatchData = (clSetPlatformDispatchDataKHR_fn)(size_t)p_clGetExtensionFunctionAddress("clSetPlatformDispatchDataKHR");
+    // try to get clIcdGetFunctionAddressForPlatformKHR and clIcdSetPlatformDispatchDataKHR to detect cl_khr_icd2 support
+    p_clIcdGetFunctionAddressForPlatform = (clIcdGetFunctionAddressForPlatformKHR_fn)(size_t)p_clGetExtensionFunctionAddress("clIcdGetFunctionAddressForPlatformKHR");
+    p_clIcdSetPlatformDispatchData = (clIcdSetPlatformDispatchDataKHR_fn)(size_t)p_clGetExtensionFunctionAddress("clIcdSetPlatformDispatchDataKHR");
 #endif
 
     // query the number of platforms available and allocate space to store them
@@ -149,14 +149,14 @@ void khrIcdVendorAdd(const char *libraryName)
         }
 
 #if KHR_LOADER_MANAGED_DISPATCH
-        if (KHR_ICD2_HAS_TAG(platforms[i]) && !p_clGetFunctionAddressForPlatform)
+        if (KHR_ICD2_HAS_TAG(platforms[i]) && !p_clIcdGetFunctionAddressForPlatform)
         {
-           KHR_ICD_TRACE("found icd 2 object, but platform is missing clGetFunctionAddressForPlatformKHR");
+           KHR_ICD_TRACE("found icd 2 object, but platform is missing clIcdGetFunctionAddressForPlatformKHR\n");
            continue;
         }
-        if (KHR_ICD2_HAS_TAG(platforms[i]) && !p_clSetPlatformDispatchData)
+        if (KHR_ICD2_HAS_TAG(platforms[i]) && !p_clIcdSetPlatformDispatchData)
         {
-           KHR_ICD_TRACE("found icd 2 object, but platform is missing clSetPlatformDispatchDataKHR");
+           KHR_ICD_TRACE("found icd 2 object, but platform is missing clIcdSetPlatformDispatchDataKHR\n");
            continue;
         }
 #endif
@@ -174,8 +174,8 @@ void khrIcdVendorAdd(const char *libraryName)
         // populate cl_khr_icd2 platform's loader managed dispatch tables
         if (KHR_ICD2_HAS_TAG(platforms[i]))
         {
-            khrIcd2PopulateDispatchTable(platforms[i], p_clGetFunctionAddressForPlatform, &vendor->dispData.dispatch);
-            p_clSetPlatformDispatchData(platforms[i], &vendor->dispData);
+            khrIcd2PopulateDispatchTable(platforms[i], p_clIcdGetFunctionAddressForPlatform, &vendor->dispData.dispatch);
+            p_clIcdSetPlatformDispatchData(platforms[i], &vendor->dispData);
             KHR_ICD_TRACE("found icd 2 platform, using loader managed dispatch\n");
         }
 #endif
diff --git a/loader/icd_dispatch.h b/loader/icd_dispatch.h
index df51b7e3..5e7445bd 100644
--- a/loader/icd_dispatch.h
+++ b/loader/icd_dispatch.h
@@ -64,24 +64,24 @@
 #define CL_ICD2_TAG_KHR ((size_t)0x4F50454E434C3331ULL)
 
 typedef void * CL_API_CALL
-clGetFunctionAddressForPlatformKHR_t(
+clIcdGetFunctionAddressForPlatformKHR_t(
     cl_platform_id platform,
     const char* func_name);
 
-typedef clGetFunctionAddressForPlatformKHR_t *
-clGetFunctionAddressForPlatformKHR_fn;
+typedef clIcdGetFunctionAddressForPlatformKHR_t *
+clIcdGetFunctionAddressForPlatformKHR_fn;
 
 typedef cl_int CL_API_CALL
-clSetPlatformDispatchDataKHR_t(
+clIcdSetPlatformDispatchDataKHR_t(
     cl_platform_id platform,
     void *disp_data);
 
-typedef clSetPlatformDispatchDataKHR_t *
-clSetPlatformDispatchDataKHR_fn;
+typedef clIcdSetPlatformDispatchDataKHR_t *
+clIcdSetPlatformDispatchDataKHR_fn;
 
 extern void khrIcd2PopulateDispatchTable(
     cl_platform_id platform,
-    clGetFunctionAddressForPlatformKHR_fn p_clGetFunctionAddressForPlatform,
+    clIcdGetFunctionAddressForPlatformKHR_fn p_clIcdGetFunctionAddressForPlatform,
     struct _cl_icd_dispatch* dispatch);
 
 #endif // defined(CL_ENABLE_LOADER_MANAGED_DISPATCH) && !defined(CL_ICD2_TAG_KHR)
diff --git a/loader/icd_dispatch_generated.c b/loader/icd_dispatch_generated.c
index 586c075f..358509b0 100644
--- a/loader/icd_dispatch_generated.c
+++ b/loader/icd_dispatch_generated.c
@@ -9170,363 +9170,363 @@ static cl_int CL_API_CALL clGetKernelSubGroupInfoKHR_unsupp(
 
 void khrIcd2PopulateDispatchTable(
     cl_platform_id platform,
-    clGetFunctionAddressForPlatformKHR_fn p_clGetFunctionAddressForPlatform,
+    clIcdGetFunctionAddressForPlatformKHR_fn p_clIcdGetFunctionAddressForPlatform,
     struct _cl_icd_dispatch* dispatch)
 {
 ///////////////////////////////////////////////////////////////////////////////
 // Core APIs:
-   dispatch->clGetPlatformIDs = (clGetPlatformIDs_t *)(size_t)p_clGetFunctionAddressForPlatform(platform, "clGetPlatformIDs");
+   dispatch->clGetPlatformIDs = (clGetPlatformIDs_t *)(size_t)p_clIcdGetFunctionAddressForPlatform(platform, "clGetPlatformIDs");
    if (!dispatch->clGetPlatformIDs)
        dispatch->clGetPlatformIDs = &clGetPlatformIDs_unsupp;
-   dispatch->clGetPlatformInfo = (clGetPlatformInfo_t *)(size_t)p_clGetFunctionAddressForPlatform(platform, "clGetPlatformInfo");
+   dispatch->clGetPlatformInfo = (clGetPlatformInfo_t *)(size_t)p_clIcdGetFunctionAddressForPlatform(platform, "clGetPlatformInfo");
    if (!dispatch->clGetPlatformInfo)
        dispatch->clGetPlatformInfo = &clGetPlatformInfo_unsupp;
-   dispatch->clGetDeviceIDs = (clGetDeviceIDs_t *)(size_t)p_clGetFunctionAddressForPlatform(platform, "clGetDeviceIDs");
+   dispatch->clGetDeviceIDs = (clGetDeviceIDs_t *)(size_t)p_clIcdGetFunctionAddressForPlatform(platform, "clGetDeviceIDs");
    if (!dispatch->clGetDeviceIDs)
        dispatch->clGetDeviceIDs = &clGetDeviceIDs_unsupp;
-   dispatch->clGetDeviceInfo = (clGetDeviceInfo_t *)(size_t)p_clGetFunctionAddressForPlatform(platform, "clGetDeviceInfo");
+   dispatch->clGetDeviceInfo = (clGetDeviceInfo_t *)(size_t)p_clIcdGetFunctionAddressForPlatform(platform, "clGetDeviceInfo");
    if (!dispatch->clGetDeviceInfo)
        dispatch->clGetDeviceInfo = &clGetDeviceInfo_unsupp;
-   dispatch->clCreateContext = (clCreateContext_t *)(size_t)p_clGetFunctionAddressForPlatform(platform, "clCreateContext");
+   dispatch->clCreateContext = (clCreateContext_t *)(size_t)p_clIcdGetFunctionAddressForPlatform(platform, "clCreateContext");
    if (!dispatch->clCreateContext)
        dispatch->clCreateContext = &clCreateContext_unsupp;
-   dispatch->clCreateContextFromType = (clCreateContextFromType_t *)(size_t)p_clGetFunctionAddressForPlatform(platform, "clCreateContextFromType");
+   dispatch->clCreateContextFromType = (clCreateContextFromType_t *)(size_t)p_clIcdGetFunctionAddressForPlatform(platform, "clCreateContextFromType");
    if (!dispatch->clCreateContextFromType)
        dispatch->clCreateContextFromType = &clCreateContextFromType_unsupp;
-   dispatch->clRetainContext = (clRetainContext_t *)(size_t)p_clGetFunctionAddressForPlatform(platform, "clRetainContext");
+   dispatch->clRetainContext = (clRetainContext_t *)(size_t)p_clIcdGetFunctionAddressForPlatform(platform, "clRetainContext");
    if (!dispatch->clRetainContext)
        dispatch->clRetainContext = &clRetainContext_unsupp;
-   dispatch->clReleaseContext = (clReleaseContext_t *)(size_t)p_clGetFunctionAddressForPlatform(platform, "clReleaseContext");
+   dispatch->clReleaseContext = (clReleaseContext_t *)(size_t)p_clIcdGetFunctionAddressForPlatform(platform, "clReleaseContext");
    if (!dispatch->clReleaseContext)
        dispatch->clReleaseContext = &clReleaseContext_unsupp;
-   dispatch->clGetContextInfo = (clGetContextInfo_t *)(size_t)p_clGetFunctionAddressForPlatform(platform, "clGetContextInfo");
+   dispatch->clGetContextInfo = (clGetContextInfo_t *)(size_t)p_clIcdGetFunctionAddressForPlatform(platform, "clGetContextInfo");
    if (!dispatch->clGetContextInfo)
        dispatch->clGetContextInfo = &clGetContextInfo_unsupp;
-   dispatch->clRetainCommandQueue = (clRetainCommandQueue_t *)(size_t)p_clGetFunctionAddressForPlatform(platform, "clRetainCommandQueue");
+   dispatch->clRetainCommandQueue = (clRetainCommandQueue_t *)(size_t)p_clIcdGetFunctionAddressForPlatform(platform, "clRetainCommandQueue");
    if (!dispatch->clRetainCommandQueue)
        dispatch->clRetainCommandQueue = &clRetainCommandQueue_unsupp;
-   dispatch->clReleaseCommandQueue = (clReleaseCommandQueue_t *)(size_t)p_clGetFunctionAddressForPlatform(platform, "clReleaseCommandQueue");
+   dispatch->clReleaseCommandQueue = (clReleaseCommandQueue_t *)(size_t)p_clIcdGetFunctionAddressForPlatform(platform, "clReleaseCommandQueue");
    if (!dispatch->clReleaseCommandQueue)
        dispatch->clReleaseCommandQueue = &clReleaseCommandQueue_unsupp;
-   dispatch->clGetCommandQueueInfo = (clGetCommandQueueInfo_t *)(size_t)p_clGetFunctionAddressForPlatform(platform, "clGetCommandQueueInfo");
+   dispatch->clGetCommandQueueInfo = (clGetCommandQueueInfo_t *)(size_t)p_clIcdGetFunctionAddressForPlatform(platform, "clGetCommandQueueInfo");
    if (!dispatch->clGetCommandQueueInfo)
        dispatch->clGetCommandQueueInfo = &clGetCommandQueueInfo_unsupp;
-   dispatch->clCreateBuffer = (clCreateBuffer_t *)(size_t)p_clGetFunctionAddressForPlatform(platform, "clCreateBuffer");
+   dispatch->clCreateBuffer = (clCreateBuffer_t *)(size_t)p_clIcdGetFunctionAddressForPlatform(platform, "clCreateBuffer");
    if (!dispatch->clCreateBuffer)
        dispatch->clCreateBuffer = &clCreateBuffer_unsupp;
-   dispatch->clRetainMemObject = (clRetainMemObject_t *)(size_t)p_clGetFunctionAddressForPlatform(platform, "clRetainMemObject");
+   dispatch->clRetainMemObject = (clRetainMemObject_t *)(size_t)p_clIcdGetFunctionAddressForPlatform(platform, "clRetainMemObject");
    if (!dispatch->clRetainMemObject)
        dispatch->clRetainMemObject = &clRetainMemObject_unsupp;
-   dispatch->clReleaseMemObject = (clReleaseMemObject_t *)(size_t)p_clGetFunctionAddressForPlatform(platform, "clReleaseMemObject");
+   dispatch->clReleaseMemObject = (clReleaseMemObject_t *)(size_t)p_clIcdGetFunctionAddressForPlatform(platform, "clReleaseMemObject");
    if (!dispatch->clReleaseMemObject)
        dispatch->clReleaseMemObject = &clReleaseMemObject_unsupp;
-   dispatch->clGetSupportedImageFormats = (clGetSupportedImageFormats_t *)(size_t)p_clGetFunctionAddressForPlatform(platform, "clGetSupportedImageFormats");
+   dispatch->clGetSupportedImageFormats = (clGetSupportedImageFormats_t *)(size_t)p_clIcdGetFunctionAddressForPlatform(platform, "clGetSupportedImageFormats");
    if (!dispatch->clGetSupportedImageFormats)
        dispatch->clGetSupportedImageFormats = &clGetSupportedImageFormats_unsupp;
-   dispatch->clGetMemObjectInfo = (clGetMemObjectInfo_t *)(size_t)p_clGetFunctionAddressForPlatform(platform, "clGetMemObjectInfo");
+   dispatch->clGetMemObjectInfo = (clGetMemObjectInfo_t *)(size_t)p_clIcdGetFunctionAddressForPlatform(platform, "clGetMemObjectInfo");
    if (!dispatch->clGetMemObjectInfo)
        dispatch->clGetMemObjectInfo = &clGetMemObjectInfo_unsupp;
-   dispatch->clGetImageInfo = (clGetImageInfo_t *)(size_t)p_clGetFunctionAddressForPlatform(platform, "clGetImageInfo");
+   dispatch->clGetImageInfo = (clGetImageInfo_t *)(size_t)p_clIcdGetFunctionAddressForPlatform(platform, "clGetImageInfo");
    if (!dispatch->clGetImageInfo)
        dispatch->clGetImageInfo = &clGetImageInfo_unsupp;
-   dispatch->clRetainSampler = (clRetainSampler_t *)(size_t)p_clGetFunctionAddressForPlatform(platform, "clRetainSampler");
+   dispatch->clRetainSampler = (clRetainSampler_t *)(size_t)p_clIcdGetFunctionAddressForPlatform(platform, "clRetainSampler");
    if (!dispatch->clRetainSampler)
        dispatch->clRetainSampler = &clRetainSampler_unsupp;
-   dispatch->clReleaseSampler = (clReleaseSampler_t *)(size_t)p_clGetFunctionAddressForPlatform(platform, "clReleaseSampler");
+   dispatch->clReleaseSampler = (clReleaseSampler_t *)(size_t)p_clIcdGetFunctionAddressForPlatform(platform, "clReleaseSampler");
    if (!dispatch->clReleaseSampler)
        dispatch->clReleaseSampler = &clReleaseSampler_unsupp;
-   dispatch->clGetSamplerInfo = (clGetSamplerInfo_t *)(size_t)p_clGetFunctionAddressForPlatform(platform, "clGetSamplerInfo");
+   dispatch->clGetSamplerInfo = (clGetSamplerInfo_t *)(size_t)p_clIcdGetFunctionAddressForPlatform(platform, "clGetSamplerInfo");
    if (!dispatch->clGetSamplerInfo)
        dispatch->clGetSamplerInfo = &clGetSamplerInfo_unsupp;
-   dispatch->clCreateProgramWithSource = (clCreateProgramWithSource_t *)(size_t)p_clGetFunctionAddressForPlatform(platform, "clCreateProgramWithSource");
+   dispatch->clCreateProgramWithSource = (clCreateProgramWithSource_t *)(size_t)p_clIcdGetFunctionAddressForPlatform(platform, "clCreateProgramWithSource");
    if (!dispatch->clCreateProgramWithSource)
        dispatch->clCreateProgramWithSource = &clCreateProgramWithSource_unsupp;
-   dispatch->clCreateProgramWithBinary = (clCreateProgramWithBinary_t *)(size_t)p_clGetFunctionAddressForPlatform(platform, "clCreateProgramWithBinary");
+   dispatch->clCreateProgramWithBinary = (clCreateProgramWithBinary_t *)(size_t)p_clIcdGetFunctionAddressForPlatform(platform, "clCreateProgramWithBinary");
    if (!dispatch->clCreateProgramWithBinary)
        dispatch->clCreateProgramWithBinary = &clCreateProgramWithBinary_unsupp;
-   dispatch->clRetainProgram = (clRetainProgram_t *)(size_t)p_clGetFunctionAddressForPlatform(platform, "clRetainProgram");
+   dispatch->clRetainProgram = (clRetainProgram_t *)(size_t)p_clIcdGetFunctionAddressForPlatform(platform, "clRetainProgram");
    if (!dispatch->clRetainProgram)
        dispatch->clRetainProgram = &clRetainProgram_unsupp;
-   dispatch->clReleaseProgram = (clReleaseProgram_t *)(size_t)p_clGetFunctionAddressForPlatform(platform, "clReleaseProgram");
+   dispatch->clReleaseProgram = (clReleaseProgram_t *)(size_t)p_clIcdGetFunctionAddressForPlatform(platform, "clReleaseProgram");
    if (!dispatch->clReleaseProgram)
        dispatch->clReleaseProgram = &clReleaseProgram_unsupp;
-   dispatch->clBuildProgram = (clBuildProgram_t *)(size_t)p_clGetFunctionAddressForPlatform(platform, "clBuildProgram");
+   dispatch->clBuildProgram = (clBuildProgram_t *)(size_t)p_clIcdGetFunctionAddressForPlatform(platform, "clBuildProgram");
    if (!dispatch->clBuildProgram)
        dispatch->clBuildProgram = &clBuildProgram_unsupp;
-   dispatch->clGetProgramInfo = (clGetProgramInfo_t *)(size_t)p_clGetFunctionAddressForPlatform(platform, "clGetProgramInfo");
+   dispatch->clGetProgramInfo = (clGetProgramInfo_t *)(size_t)p_clIcdGetFunctionAddressForPlatform(platform, "clGetProgramInfo");
    if (!dispatch->clGetProgramInfo)
        dispatch->clGetProgramInfo = &clGetProgramInfo_unsupp;
-   dispatch->clGetProgramBuildInfo = (clGetProgramBuildInfo_t *)(size_t)p_clGetFunctionAddressForPlatform(platform, "clGetProgramBuildInfo");
+   dispatch->clGetProgramBuildInfo = (clGetProgramBuildInfo_t *)(size_t)p_clIcdGetFunctionAddressForPlatform(platform, "clGetProgramBuildInfo");
    if (!dispatch->clGetProgramBuildInfo)
        dispatch->clGetProgramBuildInfo = &clGetProgramBuildInfo_unsupp;
-   dispatch->clCreateKernel = (clCreateKernel_t *)(size_t)p_clGetFunctionAddressForPlatform(platform, "clCreateKernel");
+   dispatch->clCreateKernel = (clCreateKernel_t *)(size_t)p_clIcdGetFunctionAddressForPlatform(platform, "clCreateKernel");
    if (!dispatch->clCreateKernel)
        dispatch->clCreateKernel = &clCreateKernel_unsupp;
-   dispatch->clCreateKernelsInProgram = (clCreateKernelsInProgram_t *)(size_t)p_clGetFunctionAddressForPlatform(platform, "clCreateKernelsInProgram");
+   dispatch->clCreateKernelsInProgram = (clCreateKernelsInProgram_t *)(size_t)p_clIcdGetFunctionAddressForPlatform(platform, "clCreateKernelsInProgram");
    if (!dispatch->clCreateKernelsInProgram)
        dispatch->clCreateKernelsInProgram = &clCreateKernelsInProgram_unsupp;
-   dispatch->clRetainKernel = (clRetainKernel_t *)(size_t)p_clGetFunctionAddressForPlatform(platform, "clRetainKernel");
+   dispatch->clRetainKernel = (clRetainKernel_t *)(size_t)p_clIcdGetFunctionAddressForPlatform(platform, "clRetainKernel");
    if (!dispatch->clRetainKernel)
        dispatch->clRetainKernel = &clRetainKernel_unsupp;
-   dispatch->clReleaseKernel = (clReleaseKernel_t *)(size_t)p_clGetFunctionAddressForPlatform(platform, "clReleaseKernel");
+   dispatch->clReleaseKernel = (clReleaseKernel_t *)(size_t)p_clIcdGetFunctionAddressForPlatform(platform, "clReleaseKernel");
    if (!dispatch->clReleaseKernel)
        dispatch->clReleaseKernel = &clReleaseKernel_unsupp;
-   dispatch->clSetKernelArg = (clSetKernelArg_t *)(size_t)p_clGetFunctionAddressForPlatform(platform, "clSetKernelArg");
+   dispatch->clSetKernelArg = (clSetKernelArg_t *)(size_t)p_clIcdGetFunctionAddressForPlatform(platform, "clSetKernelArg");
    if (!dispatch->clSetKernelArg)
        dispatch->clSetKernelArg = &clSetKernelArg_unsupp;
-   dispatch->clGetKernelInfo = (clGetKernelInfo_t *)(size_t)p_clGetFunctionAddressForPlatform(platform, "clGetKernelInfo");
+   dispatch->clGetKernelInfo = (clGetKernelInfo_t *)(size_t)p_clIcdGetFunctionAddressForPlatform(platform, "clGetKernelInfo");
    if (!dispatch->clGetKernelInfo)
        dispatch->clGetKernelInfo = &clGetKernelInfo_unsupp;
-   dispatch->clGetKernelWorkGroupInfo = (clGetKernelWorkGroupInfo_t *)(size_t)p_clGetFunctionAddressForPlatform(platform, "clGetKernelWorkGroupInfo");
+   dispatch->clGetKernelWorkGroupInfo = (clGetKernelWorkGroupInfo_t *)(size_t)p_clIcdGetFunctionAddressForPlatform(platform, "clGetKernelWorkGroupInfo");
    if (!dispatch->clGetKernelWorkGroupInfo)
        dispatch->clGetKernelWorkGroupInfo = &clGetKernelWorkGroupInfo_unsupp;
-   dispatch->clWaitForEvents = (clWaitForEvents_t *)(size_t)p_clGetFunctionAddressForPlatform(platform, "clWaitForEvents");
+   dispatch->clWaitForEvents = (clWaitForEvents_t *)(size_t)p_clIcdGetFunctionAddressForPlatform(platform, "clWaitForEvents");
    if (!dispatch->clWaitForEvents)
        dispatch->clWaitForEvents = &clWaitForEvents_unsupp;
-   dispatch->clGetEventInfo = (clGetEventInfo_t *)(size_t)p_clGetFunctionAddressForPlatform(platform, "clGetEventInfo");
+   dispatch->clGetEventInfo = (clGetEventInfo_t *)(size_t)p_clIcdGetFunctionAddressForPlatform(platform, "clGetEventInfo");
    if (!dispatch->clGetEventInfo)
        dispatch->clGetEventInfo = &clGetEventInfo_unsupp;
-   dispatch->clRetainEvent = (clRetainEvent_t *)(size_t)p_clGetFunctionAddressForPlatform(platform, "clRetainEvent");
+   dispatch->clRetainEvent = (clRetainEvent_t *)(size_t)p_clIcdGetFunctionAddressForPlatform(platform, "clRetainEvent");
    if (!dispatch->clRetainEvent)
        dispatch->clRetainEvent = &clRetainEvent_unsupp;
-   dispatch->clReleaseEvent = (clReleaseEvent_t *)(size_t)p_clGetFunctionAddressForPlatform(platform, "clReleaseEvent");
+   dispatch->clReleaseEvent = (clReleaseEvent_t *)(size_t)p_clIcdGetFunctionAddressForPlatform(platform, "clReleaseEvent");
    if (!dispatch->clReleaseEvent)
        dispatch->clReleaseEvent = &clReleaseEvent_unsupp;
-   dispatch->clGetEventProfilingInfo = (clGetEventProfilingInfo_t *)(size_t)p_clGetFunctionAddressForPlatform(platform, "clGetEventProfilingInfo");
+   dispatch->clGetEventProfilingInfo = (clGetEventProfilingInfo_t *)(size_t)p_clIcdGetFunctionAddressForPlatform(platform, "clGetEventProfilingInfo");
    if (!dispatch->clGetEventProfilingInfo)
        dispatch->clGetEventProfilingInfo = &clGetEventProfilingInfo_unsupp;
-   dispatch->clFlush = (clFlush_t *)(size_t)p_clGetFunctionAddressForPlatform(platform, "clFlush");
+   dispatch->clFlush = (clFlush_t *)(size_t)p_clIcdGetFunctionAddressForPlatform(platform, "clFlush");
    if (!dispatch->clFlush)
        dispatch->clFlush = &clFlush_unsupp;
-   dispatch->clFinish = (clFinish_t *)(size_t)p_clGetFunctionAddressForPlatform(platform, "clFinish");
+   dispatch->clFinish = (clFinish_t *)(size_t)p_clIcdGetFunctionAddressForPlatform(platform, "clFinish");
    if (!dispatch->clFinish)
        dispatch->clFinish = &clFinish_unsupp;
-   dispatch->clEnqueueReadBuffer = (clEnqueueReadBuffer_t *)(size_t)p_clGetFunctionAddressForPlatform(platform, "clEnqueueReadBuffer");
+   dispatch->clEnqueueReadBuffer = (clEnqueueReadBuffer_t *)(size_t)p_clIcdGetFunctionAddressForPlatform(platform, "clEnqueueReadBuffer");
    if (!dispatch->clEnqueueReadBuffer)
        dispatch->clEnqueueReadBuffer = &clEnqueueReadBuffer_unsupp;
-   dispatch->clEnqueueWriteBuffer = (clEnqueueWriteBuffer_t *)(size_t)p_clGetFunctionAddressForPlatform(platform, "clEnqueueWriteBuffer");
+   dispatch->clEnqueueWriteBuffer = (clEnqueueWriteBuffer_t *)(size_t)p_clIcdGetFunctionAddressForPlatform(platform, "clEnqueueWriteBuffer");
    if (!dispatch->clEnqueueWriteBuffer)
        dispatch->clEnqueueWriteBuffer = &clEnqueueWriteBuffer_unsupp;
-   dispatch->clEnqueueCopyBuffer = (clEnqueueCopyBuffer_t *)(size_t)p_clGetFunctionAddressForPlatform(platform, "clEnqueueCopyBuffer");
+   dispatch->clEnqueueCopyBuffer = (clEnqueueCopyBuffer_t *)(size_t)p_clIcdGetFunctionAddressForPlatform(platform, "clEnqueueCopyBuffer");
    if (!dispatch->clEnqueueCopyBuffer)
        dispatch->clEnqueueCopyBuffer = &clEnqueueCopyBuffer_unsupp;
-   dispatch->clEnqueueReadImage = (clEnqueueReadImage_t *)(size_t)p_clGetFunctionAddressForPlatform(platform, "clEnqueueReadImage");
+   dispatch->clEnqueueReadImage = (clEnqueueReadImage_t *)(size_t)p_clIcdGetFunctionAddressForPlatform(platform, "clEnqueueReadImage");
    if (!dispatch->clEnqueueReadImage)
        dispatch->clEnqueueReadImage = &clEnqueueReadImage_unsupp;
-   dispatch->clEnqueueWriteImage = (clEnqueueWriteImage_t *)(size_t)p_clGetFunctionAddressForPlatform(platform, "clEnqueueWriteImage");
+   dispatch->clEnqueueWriteImage = (clEnqueueWriteImage_t *)(size_t)p_clIcdGetFunctionAddressForPlatform(platform, "clEnqueueWriteImage");
    if (!dispatch->clEnqueueWriteImage)
        dispatch->clEnqueueWriteImage = &clEnqueueWriteImage_unsupp;
-   dispatch->clEnqueueCopyImage = (clEnqueueCopyImage_t *)(size_t)p_clGetFunctionAddressForPlatform(platform, "clEnqueueCopyImage");
+   dispatch->clEnqueueCopyImage = (clEnqueueCopyImage_t *)(size_t)p_clIcdGetFunctionAddressForPlatform(platform, "clEnqueueCopyImage");
    if (!dispatch->clEnqueueCopyImage)
        dispatch->clEnqueueCopyImage = &clEnqueueCopyImage_unsupp;
-   dispatch->clEnqueueCopyImageToBuffer = (clEnqueueCopyImageToBuffer_t *)(size_t)p_clGetFunctionAddressForPlatform(platform, "clEnqueueCopyImageToBuffer");
+   dispatch->clEnqueueCopyImageToBuffer = (clEnqueueCopyImageToBuffer_t *)(size_t)p_clIcdGetFunctionAddressForPlatform(platform, "clEnqueueCopyImageToBuffer");
    if (!dispatch->clEnqueueCopyImageToBuffer)
        dispatch->clEnqueueCopyImageToBuffer = &clEnqueueCopyImageToBuffer_unsupp;
-   dispatch->clEnqueueCopyBufferToImage = (clEnqueueCopyBufferToImage_t *)(size_t)p_clGetFunctionAddressForPlatform(platform, "clEnqueueCopyBufferToImage");
+   dispatch->clEnqueueCopyBufferToImage = (clEnqueueCopyBufferToImage_t *)(size_t)p_clIcdGetFunctionAddressForPlatform(platform, "clEnqueueCopyBufferToImage");
    if (!dispatch->clEnqueueCopyBufferToImage)
        dispatch->clEnqueueCopyBufferToImage = &clEnqueueCopyBufferToImage_unsupp;
-   dispatch->clEnqueueMapBuffer = (clEnqueueMapBuffer_t *)(size_t)p_clGetFunctionAddressForPlatform(platform, "clEnqueueMapBuffer");
+   dispatch->clEnqueueMapBuffer = (clEnqueueMapBuffer_t *)(size_t)p_clIcdGetFunctionAddressForPlatform(platform, "clEnqueueMapBuffer");
    if (!dispatch->clEnqueueMapBuffer)
        dispatch->clEnqueueMapBuffer = &clEnqueueMapBuffer_unsupp;
-   dispatch->clEnqueueMapImage = (clEnqueueMapImage_t *)(size_t)p_clGetFunctionAddressForPlatform(platform, "clEnqueueMapImage");
+   dispatch->clEnqueueMapImage = (clEnqueueMapImage_t *)(size_t)p_clIcdGetFunctionAddressForPlatform(platform, "clEnqueueMapImage");
    if (!dispatch->clEnqueueMapImage)
        dispatch->clEnqueueMapImage = &clEnqueueMapImage_unsupp;
-   dispatch->clEnqueueUnmapMemObject = (clEnqueueUnmapMemObject_t *)(size_t)p_clGetFunctionAddressForPlatform(platform, "clEnqueueUnmapMemObject");
+   dispatch->clEnqueueUnmapMemObject = (clEnqueueUnmapMemObject_t *)(size_t)p_clIcdGetFunctionAddressForPlatform(platform, "clEnqueueUnmapMemObject");
    if (!dispatch->clEnqueueUnmapMemObject)
        dispatch->clEnqueueUnmapMemObject = &clEnqueueUnmapMemObject_unsupp;
-   dispatch->clEnqueueNDRangeKernel = (clEnqueueNDRangeKernel_t *)(size_t)p_clGetFunctionAddressForPlatform(platform, "clEnqueueNDRangeKernel");
+   dispatch->clEnqueueNDRangeKernel = (clEnqueueNDRangeKernel_t *)(size_t)p_clIcdGetFunctionAddressForPlatform(platform, "clEnqueueNDRangeKernel");
    if (!dispatch->clEnqueueNDRangeKernel)
        dispatch->clEnqueueNDRangeKernel = &clEnqueueNDRangeKernel_unsupp;
-   dispatch->clEnqueueNativeKernel = (clEnqueueNativeKernel_t *)(size_t)p_clGetFunctionAddressForPlatform(platform, "clEnqueueNativeKernel");
+   dispatch->clEnqueueNativeKernel = (clEnqueueNativeKernel_t *)(size_t)p_clIcdGetFunctionAddressForPlatform(platform, "clEnqueueNativeKernel");
    if (!dispatch->clEnqueueNativeKernel)
        dispatch->clEnqueueNativeKernel = &clEnqueueNativeKernel_unsupp;
-   dispatch->clSetCommandQueueProperty = (clSetCommandQueueProperty_t *)(size_t)p_clGetFunctionAddressForPlatform(platform, "clSetCommandQueueProperty");
+   dispatch->clSetCommandQueueProperty = (clSetCommandQueueProperty_t *)(size_t)p_clIcdGetFunctionAddressForPlatform(platform, "clSetCommandQueueProperty");
    if (!dispatch->clSetCommandQueueProperty)
        dispatch->clSetCommandQueueProperty = &clSetCommandQueueProperty_unsupp;
-   dispatch->clCreateImage2D = (clCreateImage2D_t *)(size_t)p_clGetFunctionAddressForPlatform(platform, "clCreateImage2D");
+   dispatch->clCreateImage2D = (clCreateImage2D_t *)(size_t)p_clIcdGetFunctionAddressForPlatform(platform, "clCreateImage2D");
    if (!dispatch->clCreateImage2D)
        dispatch->clCreateImage2D = &clCreateImage2D_unsupp;
-   dispatch->clCreateImage3D = (clCreateImage3D_t *)(size_t)p_clGetFunctionAddressForPlatform(platform, "clCreateImage3D");
+   dispatch->clCreateImage3D = (clCreateImage3D_t *)(size_t)p_clIcdGetFunctionAddressForPlatform(platform, "clCreateImage3D");
    if (!dispatch->clCreateImage3D)
        dispatch->clCreateImage3D = &clCreateImage3D_unsupp;
-   dispatch->clEnqueueMarker = (clEnqueueMarker_t *)(size_t)p_clGetFunctionAddressForPlatform(platform, "clEnqueueMarker");
+   dispatch->clEnqueueMarker = (clEnqueueMarker_t *)(size_t)p_clIcdGetFunctionAddressForPlatform(platform, "clEnqueueMarker");
    if (!dispatch->clEnqueueMarker)
        dispatch->clEnqueueMarker = &clEnqueueMarker_unsupp;
-   dispatch->clEnqueueWaitForEvents = (clEnqueueWaitForEvents_t *)(size_t)p_clGetFunctionAddressForPlatform(platform, "clEnqueueWaitForEvents");
+   dispatch->clEnqueueWaitForEvents = (clEnqueueWaitForEvents_t *)(size_t)p_clIcdGetFunctionAddressForPlatform(platform, "clEnqueueWaitForEvents");
    if (!dispatch->clEnqueueWaitForEvents)
        dispatch->clEnqueueWaitForEvents = &clEnqueueWaitForEvents_unsupp;
-   dispatch->clEnqueueBarrier = (clEnqueueBarrier_t *)(size_t)p_clGetFunctionAddressForPlatform(platform, "clEnqueueBarrier");
+   dispatch->clEnqueueBarrier = (clEnqueueBarrier_t *)(size_t)p_clIcdGetFunctionAddressForPlatform(platform, "clEnqueueBarrier");
    if (!dispatch->clEnqueueBarrier)
        dispatch->clEnqueueBarrier = &clEnqueueBarrier_unsupp;
-   dispatch->clUnloadCompiler = (clUnloadCompiler_t *)(size_t)p_clGetFunctionAddressForPlatform(platform, "clUnloadCompiler");
+   dispatch->clUnloadCompiler = (clUnloadCompiler_t *)(size_t)p_clIcdGetFunctionAddressForPlatform(platform, "clUnloadCompiler");
    if (!dispatch->clUnloadCompiler)
        dispatch->clUnloadCompiler = &clUnloadCompiler_unsupp;
-   dispatch->clGetExtensionFunctionAddress = (clGetExtensionFunctionAddress_t *)(size_t)p_clGetFunctionAddressForPlatform(platform, "clGetExtensionFunctionAddress");
+   dispatch->clGetExtensionFunctionAddress = (clGetExtensionFunctionAddress_t *)(size_t)p_clIcdGetFunctionAddressForPlatform(platform, "clGetExtensionFunctionAddress");
    if (!dispatch->clGetExtensionFunctionAddress)
        dispatch->clGetExtensionFunctionAddress = &clGetExtensionFunctionAddress_unsupp;
-   dispatch->clCreateCommandQueue = (clCreateCommandQueue_t *)(size_t)p_clGetFunctionAddressForPlatform(platform, "clCreateCommandQueue");
+   dispatch->clCreateCommandQueue = (clCreateCommandQueue_t *)(size_t)p_clIcdGetFunctionAddressForPlatform(platform, "clCreateCommandQueue");
    if (!dispatch->clCreateCommandQueue)
        dispatch->clCreateCommandQueue = &clCreateCommandQueue_unsupp;
-   dispatch->clCreateSampler = (clCreateSampler_t *)(size_t)p_clGetFunctionAddressForPlatform(platform, "clCreateSampler");
+   dispatch->clCreateSampler = (clCreateSampler_t *)(size_t)p_clIcdGetFunctionAddressForPlatform(platform, "clCreateSampler");
    if (!dispatch->clCreateSampler)
        dispatch->clCreateSampler = &clCreateSampler_unsupp;
-   dispatch->clEnqueueTask = (clEnqueueTask_t *)(size_t)p_clGetFunctionAddressForPlatform(platform, "clEnqueueTask");
+   dispatch->clEnqueueTask = (clEnqueueTask_t *)(size_t)p_clIcdGetFunctionAddressForPlatform(platform, "clEnqueueTask");
    if (!dispatch->clEnqueueTask)
        dispatch->clEnqueueTask = &clEnqueueTask_unsupp;
-   dispatch->clCreateSubBuffer = (clCreateSubBuffer_t *)(size_t)p_clGetFunctionAddressForPlatform(platform, "clCreateSubBuffer");
+   dispatch->clCreateSubBuffer = (clCreateSubBuffer_t *)(size_t)p_clIcdGetFunctionAddressForPlatform(platform, "clCreateSubBuffer");
    if (!dispatch->clCreateSubBuffer)
        dispatch->clCreateSubBuffer = &clCreateSubBuffer_unsupp;
-   dispatch->clSetMemObjectDestructorCallback = (clSetMemObjectDestructorCallback_t *)(size_t)p_clGetFunctionAddressForPlatform(platform, "clSetMemObjectDestructorCallback");
+   dispatch->clSetMemObjectDestructorCallback = (clSetMemObjectDestructorCallback_t *)(size_t)p_clIcdGetFunctionAddressForPlatform(platform, "clSetMemObjectDestructorCallback");
    if (!dispatch->clSetMemObjectDestructorCallback)
        dispatch->clSetMemObjectDestructorCallback = &clSetMemObjectDestructorCallback_unsupp;
-   dispatch->clCreateUserEvent = (clCreateUserEvent_t *)(size_t)p_clGetFunctionAddressForPlatform(platform, "clCreateUserEvent");
+   dispatch->clCreateUserEvent = (clCreateUserEvent_t *)(size_t)p_clIcdGetFunctionAddressForPlatform(platform, "clCreateUserEvent");
    if (!dispatch->clCreateUserEvent)
        dispatch->clCreateUserEvent = &clCreateUserEvent_unsupp;
-   dispatch->clSetUserEventStatus = (clSetUserEventStatus_t *)(size_t)p_clGetFunctionAddressForPlatform(platform, "clSetUserEventStatus");
+   dispatch->clSetUserEventStatus = (clSetUserEventStatus_t *)(size_t)p_clIcdGetFunctionAddressForPlatform(platform, "clSetUserEventStatus");
    if (!dispatch->clSetUserEventStatus)
        dispatch->clSetUserEventStatus = &clSetUserEventStatus_unsupp;
-   dispatch->clSetEventCallback = (clSetEventCallback_t *)(size_t)p_clGetFunctionAddressForPlatform(platform, "clSetEventCallback");
+   dispatch->clSetEventCallback = (clSetEventCallback_t *)(size_t)p_clIcdGetFunctionAddressForPlatform(platform, "clSetEventCallback");
    if (!dispatch->clSetEventCallback)
        dispatch->clSetEventCallback = &clSetEventCallback_unsupp;
-   dispatch->clEnqueueReadBufferRect = (clEnqueueReadBufferRect_t *)(size_t)p_clGetFunctionAddressForPlatform(platform, "clEnqueueReadBufferRect");
+   dispatch->clEnqueueReadBufferRect = (clEnqueueReadBufferRect_t *)(size_t)p_clIcdGetFunctionAddressForPlatform(platform, "clEnqueueReadBufferRect");
    if (!dispatch->clEnqueueReadBufferRect)
        dispatch->clEnqueueReadBufferRect = &clEnqueueReadBufferRect_unsupp;
-   dispatch->clEnqueueWriteBufferRect = (clEnqueueWriteBufferRect_t *)(size_t)p_clGetFunctionAddressForPlatform(platform, "clEnqueueWriteBufferRect");
+   dispatch->clEnqueueWriteBufferRect = (clEnqueueWriteBufferRect_t *)(size_t)p_clIcdGetFunctionAddressForPlatform(platform, "clEnqueueWriteBufferRect");
    if (!dispatch->clEnqueueWriteBufferRect)
        dispatch->clEnqueueWriteBufferRect = &clEnqueueWriteBufferRect_unsupp;
-   dispatch->clEnqueueCopyBufferRect = (clEnqueueCopyBufferRect_t *)(size_t)p_clGetFunctionAddressForPlatform(platform, "clEnqueueCopyBufferRect");
+   dispatch->clEnqueueCopyBufferRect = (clEnqueueCopyBufferRect_t *)(size_t)p_clIcdGetFunctionAddressForPlatform(platform, "clEnqueueCopyBufferRect");
    if (!dispatch->clEnqueueCopyBufferRect)
        dispatch->clEnqueueCopyBufferRect = &clEnqueueCopyBufferRect_unsupp;
-   dispatch->clCreateSubDevices = (clCreateSubDevices_t *)(size_t)p_clGetFunctionAddressForPlatform(platform, "clCreateSubDevices");
+   dispatch->clCreateSubDevices = (clCreateSubDevices_t *)(size_t)p_clIcdGetFunctionAddressForPlatform(platform, "clCreateSubDevices");
    if (!dispatch->clCreateSubDevices)
        dispatch->clCreateSubDevices = &clCreateSubDevices_unsupp;
-   dispatch->clRetainDevice = (clRetainDevice_t *)(size_t)p_clGetFunctionAddressForPlatform(platform, "clRetainDevice");
+   dispatch->clRetainDevice = (clRetainDevice_t *)(size_t)p_clIcdGetFunctionAddressForPlatform(platform, "clRetainDevice");
    if (!dispatch->clRetainDevice)
        dispatch->clRetainDevice = &clRetainDevice_unsupp;
-   dispatch->clReleaseDevice = (clReleaseDevice_t *)(size_t)p_clGetFunctionAddressForPlatform(platform, "clReleaseDevice");
+   dispatch->clReleaseDevice = (clReleaseDevice_t *)(size_t)p_clIcdGetFunctionAddressForPlatform(platform, "clReleaseDevice");
    if (!dispatch->clReleaseDevice)
        dispatch->clReleaseDevice = &clReleaseDevice_unsupp;
-   dispatch->clCreateImage = (clCreateImage_t *)(size_t)p_clGetFunctionAddressForPlatform(platform, "clCreateImage");
+   dispatch->clCreateImage = (clCreateImage_t *)(size_t)p_clIcdGetFunctionAddressForPlatform(platform, "clCreateImage");
    if (!dispatch->clCreateImage)
        dispatch->clCreateImage = &clCreateImage_unsupp;
-   dispatch->clCreateProgramWithBuiltInKernels = (clCreateProgramWithBuiltInKernels_t *)(size_t)p_clGetFunctionAddressForPlatform(platform, "clCreateProgramWithBuiltInKernels");
+   dispatch->clCreateProgramWithBuiltInKernels = (clCreateProgramWithBuiltInKernels_t *)(size_t)p_clIcdGetFunctionAddressForPlatform(platform, "clCreateProgramWithBuiltInKernels");
    if (!dispatch->clCreateProgramWithBuiltInKernels)
        dispatch->clCreateProgramWithBuiltInKernels = &clCreateProgramWithBuiltInKernels_unsupp;
-   dispatch->clCompileProgram = (clCompileProgram_t *)(size_t)p_clGetFunctionAddressForPlatform(platform, "clCompileProgram");
+   dispatch->clCompileProgram = (clCompileProgram_t *)(size_t)p_clIcdGetFunctionAddressForPlatform(platform, "clCompileProgram");
    if (!dispatch->clCompileProgram)
        dispatch->clCompileProgram = &clCompileProgram_unsupp;
-   dispatch->clLinkProgram = (clLinkProgram_t *)(size_t)p_clGetFunctionAddressForPlatform(platform, "clLinkProgram");
+   dispatch->clLinkProgram = (clLinkProgram_t *)(size_t)p_clIcdGetFunctionAddressForPlatform(platform, "clLinkProgram");
    if (!dispatch->clLinkProgram)
        dispatch->clLinkProgram = &clLinkProgram_unsupp;
-   dispatch->clUnloadPlatformCompiler = (clUnloadPlatformCompiler_t *)(size_t)p_clGetFunctionAddressForPlatform(platform, "clUnloadPlatformCompiler");
+   dispatch->clUnloadPlatformCompiler = (clUnloadPlatformCompiler_t *)(size_t)p_clIcdGetFunctionAddressForPlatform(platform, "clUnloadPlatformCompiler");
    if (!dispatch->clUnloadPlatformCompiler)
        dispatch->clUnloadPlatformCompiler = &clUnloadPlatformCompiler_unsupp;
-   dispatch->clGetKernelArgInfo = (clGetKernelArgInfo_t *)(size_t)p_clGetFunctionAddressForPlatform(platform, "clGetKernelArgInfo");
+   dispatch->clGetKernelArgInfo = (clGetKernelArgInfo_t *)(size_t)p_clIcdGetFunctionAddressForPlatform(platform, "clGetKernelArgInfo");
    if (!dispatch->clGetKernelArgInfo)
        dispatch->clGetKernelArgInfo = &clGetKernelArgInfo_unsupp;
-   dispatch->clEnqueueFillBuffer = (clEnqueueFillBuffer_t *)(size_t)p_clGetFunctionAddressForPlatform(platform, "clEnqueueFillBuffer");
+   dispatch->clEnqueueFillBuffer = (clEnqueueFillBuffer_t *)(size_t)p_clIcdGetFunctionAddressForPlatform(platform, "clEnqueueFillBuffer");
    if (!dispatch->clEnqueueFillBuffer)
        dispatch->clEnqueueFillBuffer = &clEnqueueFillBuffer_unsupp;
-   dispatch->clEnqueueFillImage = (clEnqueueFillImage_t *)(size_t)p_clGetFunctionAddressForPlatform(platform, "clEnqueueFillImage");
+   dispatch->clEnqueueFillImage = (clEnqueueFillImage_t *)(size_t)p_clIcdGetFunctionAddressForPlatform(platform, "clEnqueueFillImage");
    if (!dispatch->clEnqueueFillImage)
        dispatch->clEnqueueFillImage = &clEnqueueFillImage_unsupp;
-   dispatch->clEnqueueMigrateMemObjects = (clEnqueueMigrateMemObjects_t *)(size_t)p_clGetFunctionAddressForPlatform(platform, "clEnqueueMigrateMemObjects");
+   dispatch->clEnqueueMigrateMemObjects = (clEnqueueMigrateMemObjects_t *)(size_t)p_clIcdGetFunctionAddressForPlatform(platform, "clEnqueueMigrateMemObjects");
    if (!dispatch->clEnqueueMigrateMemObjects)
        dispatch->clEnqueueMigrateMemObjects = &clEnqueueMigrateMemObjects_unsupp;
-   dispatch->clEnqueueMarkerWithWaitList = (clEnqueueMarkerWithWaitList_t *)(size_t)p_clGetFunctionAddressForPlatform(platform, "clEnqueueMarkerWithWaitList");
+   dispatch->clEnqueueMarkerWithWaitList = (clEnqueueMarkerWithWaitList_t *)(size_t)p_clIcdGetFunctionAddressForPlatform(platform, "clEnqueueMarkerWithWaitList");
    if (!dispatch->clEnqueueMarkerWithWaitList)
        dispatch->clEnqueueMarkerWithWaitList = &clEnqueueMarkerWithWaitList_unsupp;
-   dispatch->clEnqueueBarrierWithWaitList = (clEnqueueBarrierWithWaitList_t *)(size_t)p_clGetFunctionAddressForPlatform(platform, "clEnqueueBarrierWithWaitList");
+   dispatch->clEnqueueBarrierWithWaitList = (clEnqueueBarrierWithWaitList_t *)(size_t)p_clIcdGetFunctionAddressForPlatform(platform, "clEnqueueBarrierWithWaitList");
    if (!dispatch->clEnqueueBarrierWithWaitList)
        dispatch->clEnqueueBarrierWithWaitList = &clEnqueueBarrierWithWaitList_unsupp;
-   dispatch->clGetExtensionFunctionAddressForPlatform = (clGetExtensionFunctionAddressForPlatform_t *)(size_t)p_clGetFunctionAddressForPlatform(platform, "clGetExtensionFunctionAddressForPlatform");
+   dispatch->clGetExtensionFunctionAddressForPlatform = (clGetExtensionFunctionAddressForPlatform_t *)(size_t)p_clIcdGetFunctionAddressForPlatform(platform, "clGetExtensionFunctionAddressForPlatform");
    if (!dispatch->clGetExtensionFunctionAddressForPlatform)
        dispatch->clGetExtensionFunctionAddressForPlatform = &clGetExtensionFunctionAddressForPlatform_unsupp;
-   dispatch->clCreateCommandQueueWithProperties = (clCreateCommandQueueWithProperties_t *)(size_t)p_clGetFunctionAddressForPlatform(platform, "clCreateCommandQueueWithProperties");
+   dispatch->clCreateCommandQueueWithProperties = (clCreateCommandQueueWithProperties_t *)(size_t)p_clIcdGetFunctionAddressForPlatform(platform, "clCreateCommandQueueWithProperties");
    if (!dispatch->clCreateCommandQueueWithProperties)
        dispatch->clCreateCommandQueueWithProperties = &clCreateCommandQueueWithProperties_unsupp;
-   dispatch->clCreatePipe = (clCreatePipe_t *)(size_t)p_clGetFunctionAddressForPlatform(platform, "clCreatePipe");
+   dispatch->clCreatePipe = (clCreatePipe_t *)(size_t)p_clIcdGetFunctionAddressForPlatform(platform, "clCreatePipe");
    if (!dispatch->clCreatePipe)
        dispatch->clCreatePipe = &clCreatePipe_unsupp;
-   dispatch->clGetPipeInfo = (clGetPipeInfo_t *)(size_t)p_clGetFunctionAddressForPlatform(platform, "clGetPipeInfo");
+   dispatch->clGetPipeInfo = (clGetPipeInfo_t *)(size_t)p_clIcdGetFunctionAddressForPlatform(platform, "clGetPipeInfo");
    if (!dispatch->clGetPipeInfo)
        dispatch->clGetPipeInfo = &clGetPipeInfo_unsupp;
-   dispatch->clSVMAlloc = (clSVMAlloc_t *)(size_t)p_clGetFunctionAddressForPlatform(platform, "clSVMAlloc");
+   dispatch->clSVMAlloc = (clSVMAlloc_t *)(size_t)p_clIcdGetFunctionAddressForPlatform(platform, "clSVMAlloc");
    if (!dispatch->clSVMAlloc)
        dispatch->clSVMAlloc = &clSVMAlloc_unsupp;
-   dispatch->clSVMFree = (clSVMFree_t *)(size_t)p_clGetFunctionAddressForPlatform(platform, "clSVMFree");
+   dispatch->clSVMFree = (clSVMFree_t *)(size_t)p_clIcdGetFunctionAddressForPlatform(platform, "clSVMFree");
    if (!dispatch->clSVMFree)
        dispatch->clSVMFree = &clSVMFree_unsupp;
-   dispatch->clCreateSamplerWithProperties = (clCreateSamplerWithProperties_t *)(size_t)p_clGetFunctionAddressForPlatform(platform, "clCreateSamplerWithProperties");
+   dispatch->clCreateSamplerWithProperties = (clCreateSamplerWithProperties_t *)(size_t)p_clIcdGetFunctionAddressForPlatform(platform, "clCreateSamplerWithProperties");
    if (!dispatch->clCreateSamplerWithProperties)
        dispatch->clCreateSamplerWithProperties = &clCreateSamplerWithProperties_unsupp;
-   dispatch->clSetKernelArgSVMPointer = (clSetKernelArgSVMPointer_t *)(size_t)p_clGetFunctionAddressForPlatform(platform, "clSetKernelArgSVMPointer");
+   dispatch->clSetKernelArgSVMPointer = (clSetKernelArgSVMPointer_t *)(size_t)p_clIcdGetFunctionAddressForPlatform(platform, "clSetKernelArgSVMPointer");
    if (!dispatch->clSetKernelArgSVMPointer)
        dispatch->clSetKernelArgSVMPointer = &clSetKernelArgSVMPointer_unsupp;
-   dispatch->clSetKernelExecInfo = (clSetKernelExecInfo_t *)(size_t)p_clGetFunctionAddressForPlatform(platform, "clSetKernelExecInfo");
+   dispatch->clSetKernelExecInfo = (clSetKernelExecInfo_t *)(size_t)p_clIcdGetFunctionAddressForPlatform(platform, "clSetKernelExecInfo");
    if (!dispatch->clSetKernelExecInfo)
        dispatch->clSetKernelExecInfo = &clSetKernelExecInfo_unsupp;
-   dispatch->clEnqueueSVMFree = (clEnqueueSVMFree_t *)(size_t)p_clGetFunctionAddressForPlatform(platform, "clEnqueueSVMFree");
+   dispatch->clEnqueueSVMFree = (clEnqueueSVMFree_t *)(size_t)p_clIcdGetFunctionAddressForPlatform(platform, "clEnqueueSVMFree");
    if (!dispatch->clEnqueueSVMFree)
        dispatch->clEnqueueSVMFree = &clEnqueueSVMFree_unsupp;
-   dispatch->clEnqueueSVMMemcpy = (clEnqueueSVMMemcpy_t *)(size_t)p_clGetFunctionAddressForPlatform(platform, "clEnqueueSVMMemcpy");
+   dispatch->clEnqueueSVMMemcpy = (clEnqueueSVMMemcpy_t *)(size_t)p_clIcdGetFunctionAddressForPlatform(platform, "clEnqueueSVMMemcpy");
    if (!dispatch->clEnqueueSVMMemcpy)
        dispatch->clEnqueueSVMMemcpy = &clEnqueueSVMMemcpy_unsupp;
-   dispatch->clEnqueueSVMMemFill = (clEnqueueSVMMemFill_t *)(size_t)p_clGetFunctionAddressForPlatform(platform, "clEnqueueSVMMemFill");
+   dispatch->clEnqueueSVMMemFill = (clEnqueueSVMMemFill_t *)(size_t)p_clIcdGetFunctionAddressForPlatform(platform, "clEnqueueSVMMemFill");
    if (!dispatch->clEnqueueSVMMemFill)
        dispatch->clEnqueueSVMMemFill = &clEnqueueSVMMemFill_unsupp;
-   dispatch->clEnqueueSVMMap = (clEnqueueSVMMap_t *)(size_t)p_clGetFunctionAddressForPlatform(platform, "clEnqueueSVMMap");
+   dispatch->clEnqueueSVMMap = (clEnqueueSVMMap_t *)(size_t)p_clIcdGetFunctionAddressForPlatform(platform, "clEnqueueSVMMap");
    if (!dispatch->clEnqueueSVMMap)
        dispatch->clEnqueueSVMMap = &clEnqueueSVMMap_unsupp;
-   dispatch->clEnqueueSVMUnmap = (clEnqueueSVMUnmap_t *)(size_t)p_clGetFunctionAddressForPlatform(platform, "clEnqueueSVMUnmap");
+   dispatch->clEnqueueSVMUnmap = (clEnqueueSVMUnmap_t *)(size_t)p_clIcdGetFunctionAddressForPlatform(platform, "clEnqueueSVMUnmap");
    if (!dispatch->clEnqueueSVMUnmap)
        dispatch->clEnqueueSVMUnmap = &clEnqueueSVMUnmap_unsupp;
-   dispatch->clSetDefaultDeviceCommandQueue = (clSetDefaultDeviceCommandQueue_t *)(size_t)p_clGetFunctionAddressForPlatform(platform, "clSetDefaultDeviceCommandQueue");
+   dispatch->clSetDefaultDeviceCommandQueue = (clSetDefaultDeviceCommandQueue_t *)(size_t)p_clIcdGetFunctionAddressForPlatform(platform, "clSetDefaultDeviceCommandQueue");
    if (!dispatch->clSetDefaultDeviceCommandQueue)
        dispatch->clSetDefaultDeviceCommandQueue = &clSetDefaultDeviceCommandQueue_unsupp;
-   dispatch->clGetDeviceAndHostTimer = (clGetDeviceAndHostTimer_t *)(size_t)p_clGetFunctionAddressForPlatform(platform, "clGetDeviceAndHostTimer");
+   dispatch->clGetDeviceAndHostTimer = (clGetDeviceAndHostTimer_t *)(size_t)p_clIcdGetFunctionAddressForPlatform(platform, "clGetDeviceAndHostTimer");
    if (!dispatch->clGetDeviceAndHostTimer)
        dispatch->clGetDeviceAndHostTimer = &clGetDeviceAndHostTimer_unsupp;
-   dispatch->clGetHostTimer = (clGetHostTimer_t *)(size_t)p_clGetFunctionAddressForPlatform(platform, "clGetHostTimer");
+   dispatch->clGetHostTimer = (clGetHostTimer_t *)(size_t)p_clIcdGetFunctionAddressForPlatform(platform, "clGetHostTimer");
    if (!dispatch->clGetHostTimer)
        dispatch->clGetHostTimer = &clGetHostTimer_unsupp;
-   dispatch->clCreateProgramWithIL = (clCreateProgramWithIL_t *)(size_t)p_clGetFunctionAddressForPlatform(platform, "clCreateProgramWithIL");
+   dispatch->clCreateProgramWithIL = (clCreateProgramWithIL_t *)(size_t)p_clIcdGetFunctionAddressForPlatform(platform, "clCreateProgramWithIL");
    if (!dispatch->clCreateProgramWithIL)
        dispatch->clCreateProgramWithIL = &clCreateProgramWithIL_unsupp;
-   dispatch->clCloneKernel = (clCloneKernel_t *)(size_t)p_clGetFunctionAddressForPlatform(platform, "clCloneKernel");
+   dispatch->clCloneKernel = (clCloneKernel_t *)(size_t)p_clIcdGetFunctionAddressForPlatform(platform, "clCloneKernel");
    if (!dispatch->clCloneKernel)
        dispatch->clCloneKernel = &clCloneKernel_unsupp;
-   dispatch->clGetKernelSubGroupInfo = (clGetKernelSubGroupInfo_t *)(size_t)p_clGetFunctionAddressForPlatform(platform, "clGetKernelSubGroupInfo");
+   dispatch->clGetKernelSubGroupInfo = (clGetKernelSubGroupInfo_t *)(size_t)p_clIcdGetFunctionAddressForPlatform(platform, "clGetKernelSubGroupInfo");
    if (!dispatch->clGetKernelSubGroupInfo)
        dispatch->clGetKernelSubGroupInfo = &clGetKernelSubGroupInfo_unsupp;
-   dispatch->clEnqueueSVMMigrateMem = (clEnqueueSVMMigrateMem_t *)(size_t)p_clGetFunctionAddressForPlatform(platform, "clEnqueueSVMMigrateMem");
+   dispatch->clEnqueueSVMMigrateMem = (clEnqueueSVMMigrateMem_t *)(size_t)p_clIcdGetFunctionAddressForPlatform(platform, "clEnqueueSVMMigrateMem");
    if (!dispatch->clEnqueueSVMMigrateMem)
        dispatch->clEnqueueSVMMigrateMem = &clEnqueueSVMMigrateMem_unsupp;
-   dispatch->clSetProgramSpecializationConstant = (clSetProgramSpecializationConstant_t *)(size_t)p_clGetFunctionAddressForPlatform(platform, "clSetProgramSpecializationConstant");
+   dispatch->clSetProgramSpecializationConstant = (clSetProgramSpecializationConstant_t *)(size_t)p_clIcdGetFunctionAddressForPlatform(platform, "clSetProgramSpecializationConstant");
    if (!dispatch->clSetProgramSpecializationConstant)
        dispatch->clSetProgramSpecializationConstant = &clSetProgramSpecializationConstant_unsupp;
-   dispatch->clSetProgramReleaseCallback = (clSetProgramReleaseCallback_t *)(size_t)p_clGetFunctionAddressForPlatform(platform, "clSetProgramReleaseCallback");
+   dispatch->clSetProgramReleaseCallback = (clSetProgramReleaseCallback_t *)(size_t)p_clIcdGetFunctionAddressForPlatform(platform, "clSetProgramReleaseCallback");
    if (!dispatch->clSetProgramReleaseCallback)
        dispatch->clSetProgramReleaseCallback = &clSetProgramReleaseCallback_unsupp;
-   dispatch->clSetContextDestructorCallback = (clSetContextDestructorCallback_t *)(size_t)p_clGetFunctionAddressForPlatform(platform, "clSetContextDestructorCallback");
+   dispatch->clSetContextDestructorCallback = (clSetContextDestructorCallback_t *)(size_t)p_clIcdGetFunctionAddressForPlatform(platform, "clSetContextDestructorCallback");
    if (!dispatch->clSetContextDestructorCallback)
        dispatch->clSetContextDestructorCallback = &clSetContextDestructorCallback_unsupp;
-   dispatch->clCreateBufferWithProperties = (clCreateBufferWithProperties_t *)(size_t)p_clGetFunctionAddressForPlatform(platform, "clCreateBufferWithProperties");
+   dispatch->clCreateBufferWithProperties = (clCreateBufferWithProperties_t *)(size_t)p_clIcdGetFunctionAddressForPlatform(platform, "clCreateBufferWithProperties");
    if (!dispatch->clCreateBufferWithProperties)
        dispatch->clCreateBufferWithProperties = &clCreateBufferWithProperties_unsupp;
-   dispatch->clCreateImageWithProperties = (clCreateImageWithProperties_t *)(size_t)p_clGetFunctionAddressForPlatform(platform, "clCreateImageWithProperties");
+   dispatch->clCreateImageWithProperties = (clCreateImageWithProperties_t *)(size_t)p_clIcdGetFunctionAddressForPlatform(platform, "clCreateImageWithProperties");
    if (!dispatch->clCreateImageWithProperties)
        dispatch->clCreateImageWithProperties = &clCreateImageWithProperties_unsupp;
 
 ///////////////////////////////////////////////////////////////////////////////
 // cl_ext_device_fission
-   dispatch->clReleaseDeviceEXT = (clReleaseDeviceEXT_t *)(size_t)p_clGetFunctionAddressForPlatform(platform, "clReleaseDeviceEXT");
+   dispatch->clReleaseDeviceEXT = (clReleaseDeviceEXT_t *)(size_t)p_clIcdGetFunctionAddressForPlatform(platform, "clReleaseDeviceEXT");
    if (!dispatch->clReleaseDeviceEXT)
        dispatch->clReleaseDeviceEXT = &clReleaseDeviceEXT_unsupp;
-   dispatch->clRetainDeviceEXT = (clRetainDeviceEXT_t *)(size_t)p_clGetFunctionAddressForPlatform(platform, "clRetainDeviceEXT");
+   dispatch->clRetainDeviceEXT = (clRetainDeviceEXT_t *)(size_t)p_clIcdGetFunctionAddressForPlatform(platform, "clRetainDeviceEXT");
    if (!dispatch->clRetainDeviceEXT)
        dispatch->clRetainDeviceEXT = &clRetainDeviceEXT_unsupp;
-   dispatch->clCreateSubDevicesEXT = (clCreateSubDevicesEXT_t *)(size_t)p_clGetFunctionAddressForPlatform(platform, "clCreateSubDevicesEXT");
+   dispatch->clCreateSubDevicesEXT = (clCreateSubDevicesEXT_t *)(size_t)p_clIcdGetFunctionAddressForPlatform(platform, "clCreateSubDevicesEXT");
    if (!dispatch->clCreateSubDevicesEXT)
        dispatch->clCreateSubDevicesEXT = &clCreateSubDevicesEXT_unsupp;
 ///////////////////////////////////////////////////////////////////////////////
@@ -9534,22 +9534,22 @@ void khrIcd2PopulateDispatchTable(
 // cl_khr_d3d10_sharing
 
 #if defined(_WIN32)
-   dispatch->clGetDeviceIDsFromD3D10KHR = (clGetDeviceIDsFromD3D10KHR_t *)(size_t)p_clGetFunctionAddressForPlatform(platform, "clGetDeviceIDsFromD3D10KHR");
+   dispatch->clGetDeviceIDsFromD3D10KHR = (clGetDeviceIDsFromD3D10KHR_t *)(size_t)p_clIcdGetFunctionAddressForPlatform(platform, "clGetDeviceIDsFromD3D10KHR");
    if (!dispatch->clGetDeviceIDsFromD3D10KHR)
        dispatch->clGetDeviceIDsFromD3D10KHR = &clGetDeviceIDsFromD3D10KHR_unsupp;
-   dispatch->clCreateFromD3D10BufferKHR = (clCreateFromD3D10BufferKHR_t *)(size_t)p_clGetFunctionAddressForPlatform(platform, "clCreateFromD3D10BufferKHR");
+   dispatch->clCreateFromD3D10BufferKHR = (clCreateFromD3D10BufferKHR_t *)(size_t)p_clIcdGetFunctionAddressForPlatform(platform, "clCreateFromD3D10BufferKHR");
    if (!dispatch->clCreateFromD3D10BufferKHR)
        dispatch->clCreateFromD3D10BufferKHR = &clCreateFromD3D10BufferKHR_unsupp;
-   dispatch->clCreateFromD3D10Texture2DKHR = (clCreateFromD3D10Texture2DKHR_t *)(size_t)p_clGetFunctionAddressForPlatform(platform, "clCreateFromD3D10Texture2DKHR");
+   dispatch->clCreateFromD3D10Texture2DKHR = (clCreateFromD3D10Texture2DKHR_t *)(size_t)p_clIcdGetFunctionAddressForPlatform(platform, "clCreateFromD3D10Texture2DKHR");
    if (!dispatch->clCreateFromD3D10Texture2DKHR)
        dispatch->clCreateFromD3D10Texture2DKHR = &clCreateFromD3D10Texture2DKHR_unsupp;
-   dispatch->clCreateFromD3D10Texture3DKHR = (clCreateFromD3D10Texture3DKHR_t *)(size_t)p_clGetFunctionAddressForPlatform(platform, "clCreateFromD3D10Texture3DKHR");
+   dispatch->clCreateFromD3D10Texture3DKHR = (clCreateFromD3D10Texture3DKHR_t *)(size_t)p_clIcdGetFunctionAddressForPlatform(platform, "clCreateFromD3D10Texture3DKHR");
    if (!dispatch->clCreateFromD3D10Texture3DKHR)
        dispatch->clCreateFromD3D10Texture3DKHR = &clCreateFromD3D10Texture3DKHR_unsupp;
-   dispatch->clEnqueueAcquireD3D10ObjectsKHR = (clEnqueueAcquireD3D10ObjectsKHR_t *)(size_t)p_clGetFunctionAddressForPlatform(platform, "clEnqueueAcquireD3D10ObjectsKHR");
+   dispatch->clEnqueueAcquireD3D10ObjectsKHR = (clEnqueueAcquireD3D10ObjectsKHR_t *)(size_t)p_clIcdGetFunctionAddressForPlatform(platform, "clEnqueueAcquireD3D10ObjectsKHR");
    if (!dispatch->clEnqueueAcquireD3D10ObjectsKHR)
        dispatch->clEnqueueAcquireD3D10ObjectsKHR = &clEnqueueAcquireD3D10ObjectsKHR_unsupp;
-   dispatch->clEnqueueReleaseD3D10ObjectsKHR = (clEnqueueReleaseD3D10ObjectsKHR_t *)(size_t)p_clGetFunctionAddressForPlatform(platform, "clEnqueueReleaseD3D10ObjectsKHR");
+   dispatch->clEnqueueReleaseD3D10ObjectsKHR = (clEnqueueReleaseD3D10ObjectsKHR_t *)(size_t)p_clIcdGetFunctionAddressForPlatform(platform, "clEnqueueReleaseD3D10ObjectsKHR");
    if (!dispatch->clEnqueueReleaseD3D10ObjectsKHR)
        dispatch->clEnqueueReleaseD3D10ObjectsKHR = &clEnqueueReleaseD3D10ObjectsKHR_unsupp;
 #endif // defined(_WIN32)
@@ -9559,22 +9559,22 @@ void khrIcd2PopulateDispatchTable(
 // cl_khr_d3d11_sharing
 
 #if defined(_WIN32)
-   dispatch->clGetDeviceIDsFromD3D11KHR = (clGetDeviceIDsFromD3D11KHR_t *)(size_t)p_clGetFunctionAddressForPlatform(platform, "clGetDeviceIDsFromD3D11KHR");
+   dispatch->clGetDeviceIDsFromD3D11KHR = (clGetDeviceIDsFromD3D11KHR_t *)(size_t)p_clIcdGetFunctionAddressForPlatform(platform, "clGetDeviceIDsFromD3D11KHR");
    if (!dispatch->clGetDeviceIDsFromD3D11KHR)
        dispatch->clGetDeviceIDsFromD3D11KHR = &clGetDeviceIDsFromD3D11KHR_unsupp;
-   dispatch->clCreateFromD3D11BufferKHR = (clCreateFromD3D11BufferKHR_t *)(size_t)p_clGetFunctionAddressForPlatform(platform, "clCreateFromD3D11BufferKHR");
+   dispatch->clCreateFromD3D11BufferKHR = (clCreateFromD3D11BufferKHR_t *)(size_t)p_clIcdGetFunctionAddressForPlatform(platform, "clCreateFromD3D11BufferKHR");
    if (!dispatch->clCreateFromD3D11BufferKHR)
        dispatch->clCreateFromD3D11BufferKHR = &clCreateFromD3D11BufferKHR_unsupp;
-   dispatch->clCreateFromD3D11Texture2DKHR = (clCreateFromD3D11Texture2DKHR_t *)(size_t)p_clGetFunctionAddressForPlatform(platform, "clCreateFromD3D11Texture2DKHR");
+   dispatch->clCreateFromD3D11Texture2DKHR = (clCreateFromD3D11Texture2DKHR_t *)(size_t)p_clIcdGetFunctionAddressForPlatform(platform, "clCreateFromD3D11Texture2DKHR");
    if (!dispatch->clCreateFromD3D11Texture2DKHR)
        dispatch->clCreateFromD3D11Texture2DKHR = &clCreateFromD3D11Texture2DKHR_unsupp;
-   dispatch->clCreateFromD3D11Texture3DKHR = (clCreateFromD3D11Texture3DKHR_t *)(size_t)p_clGetFunctionAddressForPlatform(platform, "clCreateFromD3D11Texture3DKHR");
+   dispatch->clCreateFromD3D11Texture3DKHR = (clCreateFromD3D11Texture3DKHR_t *)(size_t)p_clIcdGetFunctionAddressForPlatform(platform, "clCreateFromD3D11Texture3DKHR");
    if (!dispatch->clCreateFromD3D11Texture3DKHR)
        dispatch->clCreateFromD3D11Texture3DKHR = &clCreateFromD3D11Texture3DKHR_unsupp;
-   dispatch->clEnqueueAcquireD3D11ObjectsKHR = (clEnqueueAcquireD3D11ObjectsKHR_t *)(size_t)p_clGetFunctionAddressForPlatform(platform, "clEnqueueAcquireD3D11ObjectsKHR");
+   dispatch->clEnqueueAcquireD3D11ObjectsKHR = (clEnqueueAcquireD3D11ObjectsKHR_t *)(size_t)p_clIcdGetFunctionAddressForPlatform(platform, "clEnqueueAcquireD3D11ObjectsKHR");
    if (!dispatch->clEnqueueAcquireD3D11ObjectsKHR)
        dispatch->clEnqueueAcquireD3D11ObjectsKHR = &clEnqueueAcquireD3D11ObjectsKHR_unsupp;
-   dispatch->clEnqueueReleaseD3D11ObjectsKHR = (clEnqueueReleaseD3D11ObjectsKHR_t *)(size_t)p_clGetFunctionAddressForPlatform(platform, "clEnqueueReleaseD3D11ObjectsKHR");
+   dispatch->clEnqueueReleaseD3D11ObjectsKHR = (clEnqueueReleaseD3D11ObjectsKHR_t *)(size_t)p_clIcdGetFunctionAddressForPlatform(platform, "clEnqueueReleaseD3D11ObjectsKHR");
    if (!dispatch->clEnqueueReleaseD3D11ObjectsKHR)
        dispatch->clEnqueueReleaseD3D11ObjectsKHR = &clEnqueueReleaseD3D11ObjectsKHR_unsupp;
 #endif // defined(_WIN32)
@@ -9584,16 +9584,16 @@ void khrIcd2PopulateDispatchTable(
 // cl_khr_dx9_media_sharing
 
 #if defined(_WIN32)
-   dispatch->clGetDeviceIDsFromDX9MediaAdapterKHR = (clGetDeviceIDsFromDX9MediaAdapterKHR_t *)(size_t)p_clGetFunctionAddressForPlatform(platform, "clGetDeviceIDsFromDX9MediaAdapterKHR");
+   dispatch->clGetDeviceIDsFromDX9MediaAdapterKHR = (clGetDeviceIDsFromDX9MediaAdapterKHR_t *)(size_t)p_clIcdGetFunctionAddressForPlatform(platform, "clGetDeviceIDsFromDX9MediaAdapterKHR");
    if (!dispatch->clGetDeviceIDsFromDX9MediaAdapterKHR)
        dispatch->clGetDeviceIDsFromDX9MediaAdapterKHR = &clGetDeviceIDsFromDX9MediaAdapterKHR_unsupp;
-   dispatch->clCreateFromDX9MediaSurfaceKHR = (clCreateFromDX9MediaSurfaceKHR_t *)(size_t)p_clGetFunctionAddressForPlatform(platform, "clCreateFromDX9MediaSurfaceKHR");
+   dispatch->clCreateFromDX9MediaSurfaceKHR = (clCreateFromDX9MediaSurfaceKHR_t *)(size_t)p_clIcdGetFunctionAddressForPlatform(platform, "clCreateFromDX9MediaSurfaceKHR");
    if (!dispatch->clCreateFromDX9MediaSurfaceKHR)
        dispatch->clCreateFromDX9MediaSurfaceKHR = &clCreateFromDX9MediaSurfaceKHR_unsupp;
-   dispatch->clEnqueueAcquireDX9MediaSurfacesKHR = (clEnqueueAcquireDX9MediaSurfacesKHR_t *)(size_t)p_clGetFunctionAddressForPlatform(platform, "clEnqueueAcquireDX9MediaSurfacesKHR");
+   dispatch->clEnqueueAcquireDX9MediaSurfacesKHR = (clEnqueueAcquireDX9MediaSurfacesKHR_t *)(size_t)p_clIcdGetFunctionAddressForPlatform(platform, "clEnqueueAcquireDX9MediaSurfacesKHR");
    if (!dispatch->clEnqueueAcquireDX9MediaSurfacesKHR)
        dispatch->clEnqueueAcquireDX9MediaSurfacesKHR = &clEnqueueAcquireDX9MediaSurfacesKHR_unsupp;
-   dispatch->clEnqueueReleaseDX9MediaSurfacesKHR = (clEnqueueReleaseDX9MediaSurfacesKHR_t *)(size_t)p_clGetFunctionAddressForPlatform(platform, "clEnqueueReleaseDX9MediaSurfacesKHR");
+   dispatch->clEnqueueReleaseDX9MediaSurfacesKHR = (clEnqueueReleaseDX9MediaSurfacesKHR_t *)(size_t)p_clIcdGetFunctionAddressForPlatform(platform, "clEnqueueReleaseDX9MediaSurfacesKHR");
    if (!dispatch->clEnqueueReleaseDX9MediaSurfacesKHR)
        dispatch->clEnqueueReleaseDX9MediaSurfacesKHR = &clEnqueueReleaseDX9MediaSurfacesKHR_unsupp;
 #endif // defined(_WIN32)
@@ -9601,64 +9601,64 @@ void khrIcd2PopulateDispatchTable(
 ///////////////////////////////////////////////////////////////////////////////
 
 // cl_khr_egl_event
-   dispatch->clCreateEventFromEGLSyncKHR = (clCreateEventFromEGLSyncKHR_t *)(size_t)p_clGetFunctionAddressForPlatform(platform, "clCreateEventFromEGLSyncKHR");
+   dispatch->clCreateEventFromEGLSyncKHR = (clCreateEventFromEGLSyncKHR_t *)(size_t)p_clIcdGetFunctionAddressForPlatform(platform, "clCreateEventFromEGLSyncKHR");
    if (!dispatch->clCreateEventFromEGLSyncKHR)
        dispatch->clCreateEventFromEGLSyncKHR = &clCreateEventFromEGLSyncKHR_unsupp;
 ///////////////////////////////////////////////////////////////////////////////
 
 // cl_khr_egl_image
-   dispatch->clCreateFromEGLImageKHR = (clCreateFromEGLImageKHR_t *)(size_t)p_clGetFunctionAddressForPlatform(platform, "clCreateFromEGLImageKHR");
+   dispatch->clCreateFromEGLImageKHR = (clCreateFromEGLImageKHR_t *)(size_t)p_clIcdGetFunctionAddressForPlatform(platform, "clCreateFromEGLImageKHR");
    if (!dispatch->clCreateFromEGLImageKHR)
        dispatch->clCreateFromEGLImageKHR = &clCreateFromEGLImageKHR_unsupp;
-   dispatch->clEnqueueAcquireEGLObjectsKHR = (clEnqueueAcquireEGLObjectsKHR_t *)(size_t)p_clGetFunctionAddressForPlatform(platform, "clEnqueueAcquireEGLObjectsKHR");
+   dispatch->clEnqueueAcquireEGLObjectsKHR = (clEnqueueAcquireEGLObjectsKHR_t *)(size_t)p_clIcdGetFunctionAddressForPlatform(platform, "clEnqueueAcquireEGLObjectsKHR");
    if (!dispatch->clEnqueueAcquireEGLObjectsKHR)
        dispatch->clEnqueueAcquireEGLObjectsKHR = &clEnqueueAcquireEGLObjectsKHR_unsupp;
-   dispatch->clEnqueueReleaseEGLObjectsKHR = (clEnqueueReleaseEGLObjectsKHR_t *)(size_t)p_clGetFunctionAddressForPlatform(platform, "clEnqueueReleaseEGLObjectsKHR");
+   dispatch->clEnqueueReleaseEGLObjectsKHR = (clEnqueueReleaseEGLObjectsKHR_t *)(size_t)p_clIcdGetFunctionAddressForPlatform(platform, "clEnqueueReleaseEGLObjectsKHR");
    if (!dispatch->clEnqueueReleaseEGLObjectsKHR)
        dispatch->clEnqueueReleaseEGLObjectsKHR = &clEnqueueReleaseEGLObjectsKHR_unsupp;
 ///////////////////////////////////////////////////////////////////////////////
 
 // cl_khr_gl_event
-   dispatch->clCreateEventFromGLsyncKHR = (clCreateEventFromGLsyncKHR_t *)(size_t)p_clGetFunctionAddressForPlatform(platform, "clCreateEventFromGLsyncKHR");
+   dispatch->clCreateEventFromGLsyncKHR = (clCreateEventFromGLsyncKHR_t *)(size_t)p_clIcdGetFunctionAddressForPlatform(platform, "clCreateEventFromGLsyncKHR");
    if (!dispatch->clCreateEventFromGLsyncKHR)
        dispatch->clCreateEventFromGLsyncKHR = &clCreateEventFromGLsyncKHR_unsupp;
 ///////////////////////////////////////////////////////////////////////////////
 
 // cl_khr_gl_sharing
-   dispatch->clGetGLContextInfoKHR = (clGetGLContextInfoKHR_t *)(size_t)p_clGetFunctionAddressForPlatform(platform, "clGetGLContextInfoKHR");
+   dispatch->clGetGLContextInfoKHR = (clGetGLContextInfoKHR_t *)(size_t)p_clIcdGetFunctionAddressForPlatform(platform, "clGetGLContextInfoKHR");
    if (!dispatch->clGetGLContextInfoKHR)
        dispatch->clGetGLContextInfoKHR = &clGetGLContextInfoKHR_unsupp;
-   dispatch->clCreateFromGLBuffer = (clCreateFromGLBuffer_t *)(size_t)p_clGetFunctionAddressForPlatform(platform, "clCreateFromGLBuffer");
+   dispatch->clCreateFromGLBuffer = (clCreateFromGLBuffer_t *)(size_t)p_clIcdGetFunctionAddressForPlatform(platform, "clCreateFromGLBuffer");
    if (!dispatch->clCreateFromGLBuffer)
        dispatch->clCreateFromGLBuffer = &clCreateFromGLBuffer_unsupp;
-   dispatch->clCreateFromGLTexture = (clCreateFromGLTexture_t *)(size_t)p_clGetFunctionAddressForPlatform(platform, "clCreateFromGLTexture");
+   dispatch->clCreateFromGLTexture = (clCreateFromGLTexture_t *)(size_t)p_clIcdGetFunctionAddressForPlatform(platform, "clCreateFromGLTexture");
    if (!dispatch->clCreateFromGLTexture)
        dispatch->clCreateFromGLTexture = &clCreateFromGLTexture_unsupp;
-   dispatch->clCreateFromGLRenderbuffer = (clCreateFromGLRenderbuffer_t *)(size_t)p_clGetFunctionAddressForPlatform(platform, "clCreateFromGLRenderbuffer");
+   dispatch->clCreateFromGLRenderbuffer = (clCreateFromGLRenderbuffer_t *)(size_t)p_clIcdGetFunctionAddressForPlatform(platform, "clCreateFromGLRenderbuffer");
    if (!dispatch->clCreateFromGLRenderbuffer)
        dispatch->clCreateFromGLRenderbuffer = &clCreateFromGLRenderbuffer_unsupp;
-   dispatch->clGetGLObjectInfo = (clGetGLObjectInfo_t *)(size_t)p_clGetFunctionAddressForPlatform(platform, "clGetGLObjectInfo");
+   dispatch->clGetGLObjectInfo = (clGetGLObjectInfo_t *)(size_t)p_clIcdGetFunctionAddressForPlatform(platform, "clGetGLObjectInfo");
    if (!dispatch->clGetGLObjectInfo)
        dispatch->clGetGLObjectInfo = &clGetGLObjectInfo_unsupp;
-   dispatch->clGetGLTextureInfo = (clGetGLTextureInfo_t *)(size_t)p_clGetFunctionAddressForPlatform(platform, "clGetGLTextureInfo");
+   dispatch->clGetGLTextureInfo = (clGetGLTextureInfo_t *)(size_t)p_clIcdGetFunctionAddressForPlatform(platform, "clGetGLTextureInfo");
    if (!dispatch->clGetGLTextureInfo)
        dispatch->clGetGLTextureInfo = &clGetGLTextureInfo_unsupp;
-   dispatch->clEnqueueAcquireGLObjects = (clEnqueueAcquireGLObjects_t *)(size_t)p_clGetFunctionAddressForPlatform(platform, "clEnqueueAcquireGLObjects");
+   dispatch->clEnqueueAcquireGLObjects = (clEnqueueAcquireGLObjects_t *)(size_t)p_clIcdGetFunctionAddressForPlatform(platform, "clEnqueueAcquireGLObjects");
    if (!dispatch->clEnqueueAcquireGLObjects)
        dispatch->clEnqueueAcquireGLObjects = &clEnqueueAcquireGLObjects_unsupp;
-   dispatch->clEnqueueReleaseGLObjects = (clEnqueueReleaseGLObjects_t *)(size_t)p_clGetFunctionAddressForPlatform(platform, "clEnqueueReleaseGLObjects");
+   dispatch->clEnqueueReleaseGLObjects = (clEnqueueReleaseGLObjects_t *)(size_t)p_clIcdGetFunctionAddressForPlatform(platform, "clEnqueueReleaseGLObjects");
    if (!dispatch->clEnqueueReleaseGLObjects)
        dispatch->clEnqueueReleaseGLObjects = &clEnqueueReleaseGLObjects_unsupp;
-   dispatch->clCreateFromGLTexture2D = (clCreateFromGLTexture2D_t *)(size_t)p_clGetFunctionAddressForPlatform(platform, "clCreateFromGLTexture2D");
+   dispatch->clCreateFromGLTexture2D = (clCreateFromGLTexture2D_t *)(size_t)p_clIcdGetFunctionAddressForPlatform(platform, "clCreateFromGLTexture2D");
    if (!dispatch->clCreateFromGLTexture2D)
        dispatch->clCreateFromGLTexture2D = &clCreateFromGLTexture2D_unsupp;
-   dispatch->clCreateFromGLTexture3D = (clCreateFromGLTexture3D_t *)(size_t)p_clGetFunctionAddressForPlatform(platform, "clCreateFromGLTexture3D");
+   dispatch->clCreateFromGLTexture3D = (clCreateFromGLTexture3D_t *)(size_t)p_clIcdGetFunctionAddressForPlatform(platform, "clCreateFromGLTexture3D");
    if (!dispatch->clCreateFromGLTexture3D)
        dispatch->clCreateFromGLTexture3D = &clCreateFromGLTexture3D_unsupp;
 ///////////////////////////////////////////////////////////////////////////////
 
 // cl_khr_subgroups
-   dispatch->clGetKernelSubGroupInfoKHR = (clGetKernelSubGroupInfoKHR_t *)(size_t)p_clGetFunctionAddressForPlatform(platform, "clGetKernelSubGroupInfoKHR");
+   dispatch->clGetKernelSubGroupInfoKHR = (clGetKernelSubGroupInfoKHR_t *)(size_t)p_clIcdGetFunctionAddressForPlatform(platform, "clGetKernelSubGroupInfoKHR");
    if (!dispatch->clGetKernelSubGroupInfoKHR)
        dispatch->clGetKernelSubGroupInfoKHR = &clGetKernelSubGroupInfoKHR_unsupp;
 ///////////////////////////////////////////////////////////////////////////////
diff --git a/scripts/icd_dispatch_generated.c.mako b/scripts/icd_dispatch_generated.c.mako
index 3513d242..9686ee63 100644
--- a/scripts/icd_dispatch_generated.c.mako
+++ b/scripts/icd_dispatch_generated.c.mako
@@ -558,14 +558,14 @@ static ${api.RetType} CL_API_CALL ${api.Name}_unsupp(
 
 void khrIcd2PopulateDispatchTable(
     cl_platform_id platform,
-    clGetFunctionAddressForPlatformKHR_fn p_clGetFunctionAddressForPlatform,
+    clIcdGetFunctionAddressForPlatformKHR_fn p_clIcdGetFunctionAddressForPlatform,
     struct _cl_icd_dispatch* dispatch)
 {
 ///////////////////////////////////////////////////////////////////////////////
 // Core APIs:
 %for apis in coreapis.values():
 %for api in apis:
-   dispatch->${api.Name} = (${api.Name}_t *)(size_t)p_clGetFunctionAddressForPlatform(platform, "${api.Name}");
+   dispatch->${api.Name} = (${api.Name}_t *)(size_t)p_clIcdGetFunctionAddressForPlatform(platform, "${api.Name}");
    if (!dispatch->${api.Name})
        dispatch->${api.Name} = &${api.Name}_unsupp;
 %endfor
@@ -581,7 +581,7 @@ void khrIcd2PopulateDispatchTable(
 #if defined(_WIN32)
 %endif
 %for api in apis:
-   dispatch->${api.Name} = (${api.Name}_t *)(size_t)p_clGetFunctionAddressForPlatform(platform, "${api.Name}");
+   dispatch->${api.Name} = (${api.Name}_t *)(size_t)p_clIcdGetFunctionAddressForPlatform(platform, "${api.Name}");
    if (!dispatch->${api.Name})
        dispatch->${api.Name} = &${api.Name}_unsupp;
 %endfor