fix: add missing ZE_APICALL keyword

Signed-off-by: Mateusz Jablonski <mateusz.jablonski@intel.com>

level_zero/api/core/ze_barrier_api_entrypoints.h

@@ -14,7 +14,7 @@
 #include "graph_captured_apis.h"
 
 namespace L0 {
-ze_result_t zeCommandListAppendBarrier(
+ze_result_t ZE_APICALL zeCommandListAppendBarrier(
     ze_command_list_handle_t hCommandList,
     ze_event_handle_t hSignalEvent,
     uint32_t numWaitEvents,
@@ -28,7 +28,7 @@ ze_result_t zeCommandListAppendBarrier(
     return cmdList->appendBarrier(hSignalEvent, numWaitEvents, phWaitEvents, false);
 }
 
-ze_result_t zeCommandListAppendMemoryRangesBarrier(
+ze_result_t ZE_APICALL zeCommandListAppendMemoryRangesBarrier(
     ze_command_list_handle_t hCommandList,
     uint32_t numRanges,
     const size_t *pRangeSizes,
@@ -45,7 +45,7 @@ ze_result_t zeCommandListAppendMemoryRangesBarrier(
     return L0::CommandList::fromHandle(hCommandList)->appendMemoryRangesBarrier(numRanges, pRangeSizes, pRanges, hSignalEvent, numWaitEvents, phWaitEvents);
 }
 
-ze_result_t zeDeviceSystemBarrier(
+ze_result_t ZE_APICALL zeDeviceSystemBarrier(
     ze_device_handle_t hDevice) {
     return L0::Device::fromHandle(hDevice)->systemBarrier();
 }

level_zero/api/core/ze_cmdlist_api_entrypoints.h

@@ -15,7 +15,7 @@
 #include "graph_captured_apis.h"
 
 namespace L0 {
-ze_result_t zeCommandListCreate(
+ze_result_t ZE_APICALL zeCommandListCreate(
     ze_context_handle_t hContext,
     ze_device_handle_t hDevice,
     const ze_command_list_desc_t *desc,
@@ -23,7 +23,7 @@ ze_result_t zeCommandListCreate(
     return L0::Context::fromHandle(hContext)->createCommandList(hDevice, desc, phCommandList);
 }
 
-ze_result_t zeCommandListCreateImmediate(
+ze_result_t ZE_APICALL zeCommandListCreateImmediate(
     ze_context_handle_t hContext,
     ze_device_handle_t hDevice,
     const ze_command_queue_desc_t *altdesc,
@@ -31,22 +31,22 @@ ze_result_t zeCommandListCreateImmediate(
     return L0::Context::fromHandle(hContext)->createCommandListImmediate(hDevice, altdesc, phCommandList);
 }
 
-ze_result_t zeCommandListDestroy(
+ze_result_t ZE_APICALL zeCommandListDestroy(
     ze_command_list_handle_t hCommandList) {
     return L0::CommandList::fromHandle(hCommandList)->destroy();
 }
 
-ze_result_t zeCommandListClose(
+ze_result_t ZE_APICALL zeCommandListClose(
     ze_command_list_handle_t hCommandList) {
     return L0::CommandList::fromHandle(hCommandList)->close();
 }
 
-ze_result_t zeCommandListReset(
+ze_result_t ZE_APICALL zeCommandListReset(
     ze_command_list_handle_t hCommandList) {
     return L0::CommandList::fromHandle(hCommandList)->reset();
 }
 
-ze_result_t zeCommandListAppendWriteGlobalTimestamp(
+ze_result_t ZE_APICALL zeCommandListAppendWriteGlobalTimestamp(
     ze_command_list_handle_t hCommandList,
     uint64_t *dstptr,
     ze_event_handle_t hSignalEvent,
@@ -61,7 +61,7 @@ ze_result_t zeCommandListAppendWriteGlobalTimestamp(
     return cmdList->appendWriteGlobalTimestamp(dstptr, hSignalEvent, numWaitEvents, phWaitEvents);
 }
 
-ze_result_t zeCommandListAppendQueryKernelTimestamps(
+ze_result_t ZE_APICALL zeCommandListAppendQueryKernelTimestamps(
     ze_command_list_handle_t hCommandList,
     uint32_t numEvents,
     ze_event_handle_t *phEvents,
@@ -79,37 +79,37 @@ ze_result_t zeCommandListAppendQueryKernelTimestamps(
     return cmdList->appendQueryKernelTimestamps(numEvents, phEvents, dstptr, pOffsets, hSignalEvent, numWaitEvents, phWaitEvents);
 }
 
-ze_result_t zeCommandListGetDeviceHandle(
+ze_result_t ZE_APICALL zeCommandListGetDeviceHandle(
     ze_command_list_handle_t hCommandList,
     ze_device_handle_t *phDevice) {
     return L0::CommandList::fromHandle(hCommandList)->getDeviceHandle(phDevice);
 }
 
-ze_result_t zeCommandListGetContextHandle(
+ze_result_t ZE_APICALL zeCommandListGetContextHandle(
     ze_command_list_handle_t hCommandList,
     ze_context_handle_t *phContext) {
     return L0::CommandList::fromHandle(hCommandList)->getContextHandle(phContext);
 }
 
-ze_result_t zeCommandListGetOrdinal(
+ze_result_t ZE_APICALL zeCommandListGetOrdinal(
     ze_command_list_handle_t hCommandList,
     uint32_t *pOrdinal) {
     return L0::CommandList::fromHandle(hCommandList)->getOrdinal(pOrdinal);
 }
 
-ze_result_t zeCommandListImmediateGetIndex(
+ze_result_t ZE_APICALL zeCommandListImmediateGetIndex(
     ze_command_list_handle_t hCommandListImmediate,
     uint32_t *pIndex) {
     return L0::CommandList::fromHandle(hCommandListImmediate)->getImmediateIndex(pIndex);
 }
 
-ze_result_t zeCommandListIsImmediate(
+ze_result_t ZE_APICALL zeCommandListIsImmediate(
     ze_command_list_handle_t hCommandList,
     ze_bool_t *pIsImmediate) {
     return L0::CommandList::fromHandle(hCommandList)->isImmediate(pIsImmediate);
 }
 
-ze_result_t zeCommandListCreateCloneExp(
+ze_result_t ZE_APICALL zeCommandListCreateCloneExp(
     ze_command_list_handle_t hCommandList,
     ze_command_list_handle_t *phClonedCommandList) {
     return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
@@ -125,7 +125,7 @@ ze_result_t ZE_APICALL zeCommandListImmediateAppendCommandListsExp(
     return L0::CommandList::fromHandle(hCommandListImmediate)->appendCommandLists(numCommandLists, phCommandLists, hSignalEvent, numWaitEvents, phWaitEvents);
 }
 
-ze_result_t zeCommandListAppendSignalExternalSemaphoreExt(
+ze_result_t ZE_APICALL zeCommandListAppendSignalExternalSemaphoreExt(
     ze_command_list_handle_t hCommandList,
     uint32_t numSemaphores,
     ze_external_semaphore_ext_handle_t *phSemaphores,
@@ -142,7 +142,7 @@ ze_result_t zeCommandListAppendSignalExternalSemaphoreExt(
     return cmdList->appendSignalExternalSemaphores(numSemaphores, phSemaphores, signalParams, hSignalEvent, numWaitEvents, phWaitEvents);
 }
 
-ze_result_t zeCommandListAppendWaitExternalSemaphoreExt(
+ze_result_t ZE_APICALL zeCommandListAppendWaitExternalSemaphoreExt(
     ze_command_list_handle_t hCommandList,
     uint32_t numSemaphores,
     ze_external_semaphore_ext_handle_t *phSemaphores,
@@ -159,7 +159,7 @@ ze_result_t zeCommandListAppendWaitExternalSemaphoreExt(
     return cmdList->appendWaitExternalSemaphores(numSemaphores, phSemaphores, waitParams, hSignalEvent, numWaitEvents, phWaitEvents);
 }
 
-ze_result_t zeCommandListAppendLaunchKernelWithArguments(
+ze_result_t ZE_APICALL zeCommandListAppendLaunchKernelWithArguments(
     ze_command_list_handle_t hCommandList,
     ze_kernel_handle_t hKernel,
     const ze_group_count_t groupCounts,
@@ -180,7 +180,7 @@ ze_result_t zeCommandListAppendLaunchKernelWithArguments(
     return L0::CommandList::fromHandle(hCommandList)->appendLaunchKernelWithArguments(hKernel, groupCounts, groupSizes, pArguments, pNext, hSignalEvent, numWaitEvents, phWaitEvents);
 }
 
-ze_result_t zeCommandListAppendLaunchKernelWithParameters(
+ze_result_t ZE_APICALL zeCommandListAppendLaunchKernelWithParameters(
     ze_command_list_handle_t hCommandList,
     ze_kernel_handle_t hKernel,
     const ze_group_count_t *pGroupCounts,

level_zero/api/core/ze_cmdqueue_api_entrypoints.h

@@ -12,7 +12,7 @@
 #include <level_zero/ze_api.h>
 
 namespace L0 {
-ze_result_t zeCommandQueueCreate(
+ze_result_t ZE_APICALL zeCommandQueueCreate(
     ze_context_handle_t hContext,
     ze_device_handle_t hDevice,
     const ze_command_queue_desc_t *desc,
@@ -20,12 +20,12 @@ ze_result_t zeCommandQueueCreate(
     return L0::Context::fromHandle(hContext)->createCommandQueue(hDevice, desc, phCommandQueue);
 }
 
-ze_result_t zeCommandQueueDestroy(
+ze_result_t ZE_APICALL zeCommandQueueDestroy(
     ze_command_queue_handle_t hCommandQueue) {
     return L0::CommandQueue::fromHandle(hCommandQueue)->destroy();
 }
 
-ze_result_t zeCommandQueueExecuteCommandLists(
+ze_result_t ZE_APICALL zeCommandQueueExecuteCommandLists(
     ze_command_queue_handle_t hCommandQueue,
     uint32_t numCommandLists,
     ze_command_list_handle_t *phCommandLists,
@@ -33,19 +33,19 @@ ze_result_t zeCommandQueueExecuteCommandLists(
     return L0::CommandQueue::fromHandle(hCommandQueue)->executeCommandLists(numCommandLists, phCommandLists, hFence, true, nullptr, nullptr);
 }
 
-ze_result_t zeCommandQueueSynchronize(
+ze_result_t ZE_APICALL zeCommandQueueSynchronize(
     ze_command_queue_handle_t hCommandQueue,
     uint64_t timeout) {
     return L0::CommandQueue::fromHandle(hCommandQueue)->synchronize(timeout);
 }
 
-ze_result_t zeCommandQueueGetOrdinal(
+ze_result_t ZE_APICALL zeCommandQueueGetOrdinal(
     ze_command_queue_handle_t hCommandQueue,
     uint32_t *pOrdinal) {
     return L0::CommandQueue::fromHandle(hCommandQueue)->getOrdinal(pOrdinal);
 }
 
-ze_result_t zeCommandQueueGetIndex(
+ze_result_t ZE_APICALL zeCommandQueueGetIndex(
     ze_command_queue_handle_t hCommandQueue,
     uint32_t *pIndex) {
     return L0::CommandQueue::fromHandle(hCommandQueue)->getIndex(pIndex);

level_zero/api/core/ze_context_api_entrypoints.h

@@ -13,14 +13,14 @@
 #include <level_zero/ze_api.h>
 
 namespace L0 {
-ze_result_t zeContextCreate(
+ze_result_t ZE_APICALL zeContextCreate(
     ze_driver_handle_t hDriver,
     const ze_context_desc_t *desc,
     ze_context_handle_t *phContext) {
     return L0::DriverHandle::fromHandle(hDriver)->createContext(desc, 0u, nullptr, phContext);
 }
 
-ze_result_t zeContextCreateEx(
+ze_result_t ZE_APICALL zeContextCreateEx(
     ze_driver_handle_t hDriver,
     const ze_context_desc_t *desc,
     uint32_t numDevices,
@@ -29,15 +29,15 @@ ze_result_t zeContextCreateEx(
     return L0::DriverHandle::fromHandle(hDriver)->createContext(desc, numDevices, phDevices, phContext);
 }
 
-ze_result_t zeContextDestroy(ze_context_handle_t hContext) {
+ze_result_t ZE_APICALL zeContextDestroy(ze_context_handle_t hContext) {
     return L0::Context::fromHandle(hContext)->destroy();
 }
 
-ze_result_t zeContextGetStatus(ze_context_handle_t hContext) {
+ze_result_t ZE_APICALL zeContextGetStatus(ze_context_handle_t hContext) {
     return L0::Context::fromHandle(hContext)->getStatus();
 }
 
-ze_result_t zeVirtualMemReserve(
+ze_result_t ZE_APICALL zeVirtualMemReserve(
     ze_context_handle_t hContext,
     const void *pStart,
     size_t size,
@@ -45,14 +45,14 @@ ze_result_t zeVirtualMemReserve(
     return L0::Context::fromHandle(hContext)->reserveVirtualMem(pStart, size, pptr);
 }
 
-ze_result_t zeVirtualMemFree(
+ze_result_t ZE_APICALL zeVirtualMemFree(
     ze_context_handle_t hContext,
     const void *ptr,
     size_t size) {
     return L0::Context::fromHandle(hContext)->freeVirtualMem(ptr, size);
 }
 
-ze_result_t zeVirtualMemQueryPageSize(
+ze_result_t ZE_APICALL zeVirtualMemQueryPageSize(
     ze_context_handle_t hContext,
     ze_device_handle_t hDevice,
     size_t size,
@@ -60,7 +60,7 @@ ze_result_t zeVirtualMemQueryPageSize(
     return L0::Context::fromHandle(hContext)->queryVirtualMemPageSize(hDevice, size, pagesize);
 }
 
-ze_result_t zePhysicalMemCreate(
+ze_result_t ZE_APICALL zePhysicalMemCreate(
     ze_context_handle_t hContext,
     ze_device_handle_t hDevice,
     ze_physical_mem_desc_t *desc,
@@ -68,13 +68,13 @@ ze_result_t zePhysicalMemCreate(
     return L0::Context::fromHandle(hContext)->createPhysicalMem(hDevice, desc, phPhysicalMemory);
 }
 
-ze_result_t zePhysicalMemDestroy(
+ze_result_t ZE_APICALL zePhysicalMemDestroy(
     ze_context_handle_t hContext,
     ze_physical_mem_handle_t hPhysicalMemory) {
     return L0::Context::fromHandle(hContext)->destroyPhysicalMem(hPhysicalMemory);
 }
 
-ze_result_t zeVirtualMemMap(
+ze_result_t ZE_APICALL zeVirtualMemMap(
     ze_context_handle_t hContext,
     const void *ptr,
     size_t size,
@@ -84,14 +84,14 @@ ze_result_t zeVirtualMemMap(
     return L0::Context::fromHandle(hContext)->mapVirtualMem(ptr, size, hPhysicalMemory, offset, access);
 }
 
-ze_result_t zeVirtualMemUnmap(
+ze_result_t ZE_APICALL zeVirtualMemUnmap(
     ze_context_handle_t hContext,
     const void *ptr,
     size_t size) {
     return L0::Context::fromHandle(hContext)->unMapVirtualMem(ptr, size);
 }
 
-ze_result_t zeVirtualMemSetAccessAttribute(
+ze_result_t ZE_APICALL zeVirtualMemSetAccessAttribute(
     ze_context_handle_t hContext,
     const void *ptr,
     size_t size,
@@ -99,7 +99,7 @@ ze_result_t zeVirtualMemSetAccessAttribute(
     return L0::Context::fromHandle(hContext)->setVirtualMemAccessAttribute(ptr, size, access);
 }
 
-ze_result_t zeVirtualMemGetAccessAttribute(
+ze_result_t ZE_APICALL zeVirtualMemGetAccessAttribute(
     ze_context_handle_t hContext,
     const void *ptr,
     size_t size,
@@ -108,13 +108,13 @@ ze_result_t zeVirtualMemGetAccessAttribute(
     return L0::Context::fromHandle(hContext)->getVirtualMemAccessAttribute(ptr, size, access, outSize);
 }
 
-ze_result_t zeContextSystemBarrier(
+ze_result_t ZE_APICALL zeContextSystemBarrier(
     ze_context_handle_t hContext,
     ze_device_handle_t hDevice) {
     return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
 }
 
-ze_result_t zeContextMakeMemoryResident(
+ze_result_t ZE_APICALL zeContextMakeMemoryResident(
     ze_context_handle_t hContext,
     ze_device_handle_t hDevice,
     void *ptr,
@@ -122,7 +122,7 @@ ze_result_t zeContextMakeMemoryResident(
     return L0::Context::fromHandle(hContext)->makeMemoryResident(hDevice, ptr, size);
 }
 
-ze_result_t zeContextEvictMemory(
+ze_result_t ZE_APICALL zeContextEvictMemory(
     ze_context_handle_t hContext,
     ze_device_handle_t hDevice,
     void *ptr,
@@ -130,14 +130,14 @@ ze_result_t zeContextEvictMemory(
     return L0::Context::fromHandle(hContext)->evictMemory(hDevice, ptr, size);
 }
 
-ze_result_t zeContextMakeImageResident(
+ze_result_t ZE_APICALL zeContextMakeImageResident(
     ze_context_handle_t hContext,
     ze_device_handle_t hDevice,
     ze_image_handle_t hImage) {
     return L0::Context::fromHandle(hContext)->makeImageResident(hDevice, hImage);
 }
 
-ze_result_t zeContextEvictImage(
+ze_result_t ZE_APICALL zeContextEvictImage(
     ze_context_handle_t hContext,
     ze_device_handle_t hDevice,
     ze_image_handle_t hImage) {

level_zero/api/core/ze_copy_api_entrypoints.h

@@ -16,7 +16,7 @@
 #include "graph_captured_apis.h"
 
 namespace L0 {
-ze_result_t zeCommandListAppendMemoryCopy(
+ze_result_t ZE_APICALL zeCommandListAppendMemoryCopy(
     ze_command_list_handle_t hCommandList,
     void *dstptr,
     const void *srcptr,
@@ -34,7 +34,7 @@ ze_result_t zeCommandListAppendMemoryCopy(
     return cmdList->appendMemoryCopy(dstptr, srcptr, size, hSignalEvent, numWaitEvents, phWaitEvents, memoryCopyParams);
 }
 
-ze_result_t zeCommandListAppendMemoryFill(
+ze_result_t ZE_APICALL zeCommandListAppendMemoryFill(
     ze_command_list_handle_t hCommandList,
     void *ptr,
     const void *pattern,
@@ -56,7 +56,7 @@ ze_result_t zeCommandListAppendMemoryFill(
     return cmdList->appendMemoryFill(ptr, pattern, patternSize, size, hEvent, numWaitEvents, phWaitEvents, memoryCopyParams);
 }
 
-ze_result_t zeCommandListAppendMemoryCopyRegion(
+ze_result_t ZE_APICALL zeCommandListAppendMemoryCopyRegion(
     ze_command_list_handle_t hCommandList,
     void *dstptr,
     const ze_copy_region_t *dstRegion,
@@ -79,7 +79,7 @@ ze_result_t zeCommandListAppendMemoryCopyRegion(
     return cmdList->appendMemoryCopyRegion(dstptr, dstRegion, dstPitch, dstSlicePitch, srcptr, srcRegion, srcPitch, srcSlicePitch, hEvent, numWaitEvents, phWaitEvents, memoryCopyParams);
 }
 
-ze_result_t zeCommandListAppendImageCopy(
+ze_result_t ZE_APICALL zeCommandListAppendImageCopy(
     ze_command_list_handle_t hCommandList,
     ze_image_handle_t hDstImage,
     ze_image_handle_t hSrcImage,
@@ -96,7 +96,7 @@ ze_result_t zeCommandListAppendImageCopy(
     return cmdList->appendImageCopy(hDstImage, hSrcImage, hSignalEvent, numWaitEvents, phWaitEvents, memoryCopyParams);
 }
 
-ze_result_t zeCommandListAppendImageCopyRegion(
+ze_result_t ZE_APICALL zeCommandListAppendImageCopyRegion(
     ze_command_list_handle_t hCommandList,
     ze_image_handle_t hDstImage,
     ze_image_handle_t hSrcImage,
@@ -115,7 +115,7 @@ ze_result_t zeCommandListAppendImageCopyRegion(
     return cmdList->appendImageCopyRegion(hDstImage, hSrcImage, pDstRegion, pSrcRegion, hSignalEvent, numWaitEvents, phWaitEvents, memoryCopyParams);
 }
 
-ze_result_t zeCommandListAppendImageCopyToMemory(
+ze_result_t ZE_APICALL zeCommandListAppendImageCopyToMemory(
     ze_command_list_handle_t hCommandList,
     void *dstptr,
     ze_image_handle_t hSrcImage,
@@ -133,7 +133,7 @@ ze_result_t zeCommandListAppendImageCopyToMemory(
     return cmdList->appendImageCopyToMemory(dstptr, hSrcImage, pSrcRegion, hSignalEvent, numWaitEvents, phWaitEvents, memoryCopyParams);
 }
 
-ze_result_t zeCommandListAppendImageCopyFromMemory(
+ze_result_t ZE_APICALL zeCommandListAppendImageCopyFromMemory(
     ze_command_list_handle_t hCommandList,
     ze_image_handle_t hDstImage,
     const void *srcptr,
@@ -151,7 +151,7 @@ ze_result_t zeCommandListAppendImageCopyFromMemory(
     return cmdList->appendImageCopyFromMemory(hDstImage, srcptr, pDstRegion, hSignalEvent, numWaitEvents, phWaitEvents, memoryCopyParams);
 }
 
-ze_result_t zeCommandListAppendImageCopyToMemoryExt(
+ze_result_t ZE_APICALL zeCommandListAppendImageCopyToMemoryExt(
     ze_command_list_handle_t hCommandList,
     void *dstptr,
     ze_image_handle_t hSrcImage,
@@ -171,7 +171,7 @@ ze_result_t zeCommandListAppendImageCopyToMemoryExt(
     return cmdList->appendImageCopyToMemoryExt(dstptr, hSrcImage, pSrcRegion, destRowPitch, destSlicePitch, hSignalEvent, numWaitEvents, phWaitEvents, memoryCopyParams);
 }
 
-ze_result_t zeCommandListAppendImageCopyFromMemoryExt(
+ze_result_t ZE_APICALL zeCommandListAppendImageCopyFromMemoryExt(
     ze_command_list_handle_t hCommandList,
     ze_image_handle_t hDstImage,
     const void *srcptr,
@@ -191,7 +191,7 @@ ze_result_t zeCommandListAppendImageCopyFromMemoryExt(
     return cmdList->appendImageCopyFromMemoryExt(hDstImage, srcptr, pDstRegion, srcRowPitch, srcSlicePitch, hSignalEvent, numWaitEvents, phWaitEvents, memoryCopyParams);
 }
 
-ze_result_t zeCommandListAppendMemoryPrefetch(
+ze_result_t ZE_APICALL zeCommandListAppendMemoryPrefetch(
     ze_command_list_handle_t hCommandList,
     const void *ptr,
     size_t size) {
@@ -204,7 +204,7 @@ ze_result_t zeCommandListAppendMemoryPrefetch(
     return cmdList->appendMemoryPrefetch(ptr, size);
 }
 
-ze_result_t zeCommandListAppendMemAdvise(
+ze_result_t ZE_APICALL zeCommandListAppendMemAdvise(
     ze_command_list_handle_t hCommandList,
     ze_device_handle_t hDevice,
     const void *ptr,
@@ -219,7 +219,7 @@ ze_result_t zeCommandListAppendMemAdvise(
     return cmdList->appendMemAdvise(hDevice, ptr, size, advice);
 }
 
-ze_result_t zeCommandListAppendMemoryCopyFromContext(
+ze_result_t ZE_APICALL zeCommandListAppendMemoryCopyFromContext(
     ze_command_list_handle_t hCommandList,
     void *dstptr,
     ze_context_handle_t hContextSrc,

level_zero/api/core/ze_device_api_entrypoints.h

@@ -14,111 +14,111 @@
 #include <level_zero/ze_ddi.h>
 
 namespace L0 {
-ze_result_t zeDeviceGet(
+ze_result_t ZE_APICALL zeDeviceGet(
     ze_driver_handle_t hDriver,
     uint32_t *pCount,
     ze_device_handle_t *phDevices) {
     return L0::DriverHandle::fromHandle(hDriver)->getDevice(pCount, phDevices);
 }
 
-ze_result_t zeDeviceGetSubDevices(
+ze_result_t ZE_APICALL zeDeviceGetSubDevices(
     ze_device_handle_t hDevice,
     uint32_t *pCount,
     ze_device_handle_t *phSubdevices) {
     return L0::Device::fromHandle(hDevice)->getSubDevices(pCount, phSubdevices);
 }
 
-ze_result_t zeDeviceGetProperties(
+ze_result_t ZE_APICALL zeDeviceGetProperties(
     ze_device_handle_t hDevice,
     ze_device_properties_t *pDeviceProperties) {
     return L0::Device::fromHandle(hDevice)->getProperties(pDeviceProperties);
 }
 
-ze_result_t zeDeviceGetComputeProperties(
+ze_result_t ZE_APICALL zeDeviceGetComputeProperties(
     ze_device_handle_t hDevice,
     ze_device_compute_properties_t *pComputeProperties) {
     return L0::Device::fromHandle(hDevice)->getComputeProperties(pComputeProperties);
 }
 
-ze_result_t zeDeviceGetModuleProperties(
+ze_result_t ZE_APICALL zeDeviceGetModuleProperties(
     ze_device_handle_t hDevice,
     ze_device_module_properties_t *pKernelProperties) {
     return L0::Device::fromHandle(hDevice)->getKernelProperties(pKernelProperties);
 }
 
-ze_result_t zeDeviceGetMemoryProperties(
+ze_result_t ZE_APICALL zeDeviceGetMemoryProperties(
     ze_device_handle_t hDevice,
     uint32_t *pCount,
     ze_device_memory_properties_t *pMemProperties) {
     return L0::Device::fromHandle(hDevice)->getMemoryProperties(pCount, pMemProperties);
 }
 
-ze_result_t zeDeviceGetMemoryAccessProperties(
+ze_result_t ZE_APICALL zeDeviceGetMemoryAccessProperties(
     ze_device_handle_t hDevice,
     ze_device_memory_access_properties_t *pMemAccessProperties) {
     return L0::Device::fromHandle(hDevice)->getMemoryAccessProperties(pMemAccessProperties);
 }
 
-ze_result_t zeDeviceGetCacheProperties(
+ze_result_t ZE_APICALL zeDeviceGetCacheProperties(
     ze_device_handle_t hDevice,
     uint32_t *pCount,
     ze_device_cache_properties_t *pCacheProperties) {
     return L0::Device::fromHandle(hDevice)->getCacheProperties(pCount, pCacheProperties);
 }
 
-ze_result_t zeDeviceGetImageProperties(
+ze_result_t ZE_APICALL zeDeviceGetImageProperties(
     ze_device_handle_t hDevice,
     ze_device_image_properties_t *pImageProperties) {
     return L0::Device::fromHandle(hDevice)->getDeviceImageProperties(pImageProperties);
 }
 
-ze_result_t zeDeviceGetP2PProperties(
+ze_result_t ZE_APICALL zeDeviceGetP2PProperties(
     ze_device_handle_t hDevice,
     ze_device_handle_t hPeerDevice,
     ze_device_p2p_properties_t *pP2PProperties) {
     return L0::Device::fromHandle(hDevice)->getP2PProperties(hPeerDevice, pP2PProperties);
 }
 
-ze_result_t zeDeviceCanAccessPeer(
+ze_result_t ZE_APICALL zeDeviceCanAccessPeer(
     ze_device_handle_t hDevice,
     ze_device_handle_t hPeerDevice,
     ze_bool_t *value) {
     return L0::Device::fromHandle(hDevice)->canAccessPeer(hPeerDevice, value);
 }
 
-ze_result_t zeDeviceGetCommandQueueGroupProperties(
+ze_result_t ZE_APICALL zeDeviceGetCommandQueueGroupProperties(
     ze_device_handle_t hDevice,
     uint32_t *pCount,
     ze_command_queue_group_properties_t *pCommandQueueGroupProperties) {
     return L0::Device::fromHandle(hDevice)->getCommandQueueGroupProperties(pCount, pCommandQueueGroupProperties);
 }
 
-ze_result_t zeDeviceGetExternalMemoryProperties(
+ze_result_t ZE_APICALL zeDeviceGetExternalMemoryProperties(
     ze_device_handle_t hDevice,
     ze_device_external_memory_properties_t *pExternalMemoryProperties) {
     return L0::Device::fromHandle(hDevice)->getExternalMemoryProperties(pExternalMemoryProperties);
 }
 
-ze_result_t zeDeviceGetStatus(
+ze_result_t ZE_APICALL zeDeviceGetStatus(
     ze_device_handle_t hDevice) {
     return L0::Device::fromHandle(hDevice)->getStatus();
 }
 
-ze_result_t zeDeviceGetGlobalTimestamps(
+ze_result_t ZE_APICALL zeDeviceGetGlobalTimestamps(
     ze_device_handle_t hDevice,
     uint64_t *hostTimestamp,
     uint64_t *deviceTimestamp) {
     return L0::Device::fromHandle(hDevice)->getGlobalTimestamps(hostTimestamp, deviceTimestamp);
 }
 
-ze_result_t zeDeviceReserveCacheExt(
+ze_result_t ZE_APICALL zeDeviceReserveCacheExt(
     ze_device_handle_t hDevice,
     size_t cacheLevel,
     size_t cacheReservationSize) {
     return L0::Device::fromHandle(hDevice)->reserveCache(cacheLevel, cacheReservationSize);
 }
 
-ze_result_t zeDeviceSetCacheAdviceExt(
+ze_result_t ZE_APICALL zeDeviceSetCacheAdviceExt(
     ze_device_handle_t hDevice,
     void *ptr,
     size_t regionSize,
@@ -126,38 +126,38 @@ ze_result_t zeDeviceSetCacheAdviceExt(
     return L0::Device::fromHandle(hDevice)->setCacheAdvice(ptr, regionSize, cacheRegion);
 }
 
-ze_result_t zeDevicePciGetPropertiesExt(
+ze_result_t ZE_APICALL zeDevicePciGetPropertiesExt(
     ze_device_handle_t hDevice,
     ze_pci_ext_properties_t *pPciProperties) {
     return L0::Device::fromHandle(hDevice)->getPciProperties(pPciProperties);
 }
 
-ze_result_t zeDeviceGetRootDevice(
+ze_result_t ZE_APICALL zeDeviceGetRootDevice(
     ze_device_handle_t hDevice,
     ze_device_handle_t *phRootDevice) {
     return L0::Device::fromHandle(hDevice)->getRootDevice(phRootDevice);
 }
 
-ze_result_t zeDeviceImportExternalSemaphoreExt(
+ze_result_t ZE_APICALL zeDeviceImportExternalSemaphoreExt(
     ze_device_handle_t hDevice,
     const ze_external_semaphore_ext_desc_t *desc,
     ze_external_semaphore_ext_handle_t *phSemaphore) {
     return L0::ExternalSemaphore::importExternalSemaphore(hDevice, desc, phSemaphore);
 }
 
-ze_result_t zeDeviceReleaseExternalSemaphoreExt(
+ze_result_t ZE_APICALL zeDeviceReleaseExternalSemaphoreExt(
     ze_external_semaphore_ext_handle_t hSemaphore) {
     return L0::ExternalSemaphoreImp::fromHandle(hSemaphore)->releaseExternalSemaphore();
 }
 
-ze_result_t zeDeviceGetVectorWidthPropertiesExt(
+ze_result_t ZE_APICALL zeDeviceGetVectorWidthPropertiesExt(
     ze_device_handle_t hDevice,
     uint32_t *pCount,
     ze_device_vector_width_properties_ext_t *pVectorWidthProperties) {
     return L0::Device::fromHandle(hDevice)->getVectorWidthPropertiesExt(pCount, pVectorWidthProperties);
 }
 
-ze_result_t zeDeviceSynchronize(ze_device_handle_t hDevice) {
+ze_result_t ZE_APICALL zeDeviceSynchronize(ze_device_handle_t hDevice) {
     return L0::Device::fromHandle(hDevice)->synchronize();
 }
 ze_result_t ZE_APICALL zeDeviceGetPriorityLevels(

level_zero/api/core/ze_driver_api_entrypoints.h

@@ -12,67 +12,67 @@
 #include <level_zero/ze_api.h>
 
 namespace L0 {
-ze_result_t zeInit(
+ze_result_t ZE_APICALL zeInit(
     ze_init_flags_t flags) {
     return L0::init(flags);
 }
 
-ze_result_t zeInitDrivers(
+ze_result_t ZE_APICALL zeInitDrivers(
     uint32_t *pCount, ze_driver_handle_t *phDrivers, ze_init_driver_type_desc_t *desc) {
     return L0::initDrivers(pCount, phDrivers, desc);
 }
 
-ze_result_t zeDriverGet(
+ze_result_t ZE_APICALL zeDriverGet(
     uint32_t *pCount,
     ze_driver_handle_t *phDrivers) {
     return L0::Driver::get()->driverHandleGet(pCount, phDrivers);
 }
 
-ze_result_t zeDriverGetProperties(
+ze_result_t ZE_APICALL zeDriverGetProperties(
     ze_driver_handle_t hDriver,
     ze_driver_properties_t *pProperties) {
     return L0::DriverHandle::fromHandle(hDriver)->getProperties(pProperties);
 }
 
-ze_result_t zeDriverGetApiVersion(
+ze_result_t ZE_APICALL zeDriverGetApiVersion(
     ze_driver_handle_t hDriver,
     ze_api_version_t *version) {
     return L0::DriverHandle::fromHandle(hDriver)->getApiVersion(version);
 }
 
-ze_result_t zeDriverGetIpcProperties(
+ze_result_t ZE_APICALL zeDriverGetIpcProperties(
     ze_driver_handle_t hDriver,
     ze_driver_ipc_properties_t *pIPCProperties) {
     return L0::DriverHandle::fromHandle(hDriver)->getIPCProperties(pIPCProperties);
 }
 
-ze_result_t zeDriverGetLastErrorDescription(
+ze_result_t ZE_APICALL zeDriverGetLastErrorDescription(
     ze_driver_handle_t hDriver,
     const char **ppString) {
     return L0::DriverHandle::fromHandle(hDriver)->getErrorDescription(ppString);
 }
 
-ze_result_t zeDriverGetExtensionProperties(
+ze_result_t ZE_APICALL zeDriverGetExtensionProperties(
     ze_driver_handle_t hDriver,
     uint32_t *pCount,
     ze_driver_extension_properties_t *pExtensionProperties) {
     return L0::DriverHandle::fromHandle(hDriver)->getExtensionProperties(pCount, pExtensionProperties);
 }
 
-ze_result_t zeDriverGetExtensionFunctionAddress(
+ze_result_t ZE_APICALL zeDriverGetExtensionFunctionAddress(
     ze_driver_handle_t hDriver,
     const char *name,
     void **ppFunctionAddress) {
     return L0::BaseDriver::fromHandle(hDriver)->getExtensionFunctionAddress(name, ppFunctionAddress);
 }
 
-ze_result_t zeDriverRTASFormatCompatibilityCheckExt(ze_driver_handle_t hDriver,
-                                                    ze_rtas_format_ext_t rtasFormatA,
-                                                    ze_rtas_format_ext_t rtasFormatB) {
+ze_result_t ZE_APICALL zeDriverRTASFormatCompatibilityCheckExt(ze_driver_handle_t hDriver,
+                                                               ze_rtas_format_ext_t rtasFormatA,
+                                                               ze_rtas_format_ext_t rtasFormatB) {
     return L0::DriverHandle::fromHandle(hDriver)->formatRTASCompatibilityCheckExt(rtasFormatA, rtasFormatB);
 }
 
-ze_context_handle_t zeDriverGetDefaultContext(
+ze_context_handle_t ZE_APICALL zeDriverGetDefaultContext(
     ze_driver_handle_t hDriver) {
     return L0::DriverHandle::fromHandle(hDriver)->getDefaultContext();
 }

level_zero/api/core/ze_event_api_entrypoints.h

@@ -13,7 +13,7 @@
 #include "graph_captured_apis.h"
 
 namespace L0 {
-ze_result_t zeEventPoolCreate(
+ze_result_t ZE_APICALL zeEventPoolCreate(
     ze_context_handle_t hContext,
     const ze_event_pool_desc_t *desc,
     uint32_t numDevices,
@@ -22,42 +22,42 @@ ze_result_t zeEventPoolCreate(
     return L0::Context::fromHandle(hContext)->createEventPool(desc, numDevices, phDevices, phEventPool);
 }
 
-ze_result_t zeEventPoolDestroy(
+ze_result_t ZE_APICALL zeEventPoolDestroy(
     ze_event_pool_handle_t hEventPool) {
     return L0::EventPool::fromHandle(hEventPool)->destroy();
 }
 
-ze_result_t zeEventCreate(
+ze_result_t ZE_APICALL zeEventCreate(
     ze_event_pool_handle_t hEventPool,
     const ze_event_desc_t *desc,
     ze_event_handle_t *phEvent) {
     return L0::EventPool::fromHandle(hEventPool)->createEvent(desc, phEvent);
 }
 
-ze_result_t zeEventDestroy(
+ze_result_t ZE_APICALL zeEventDestroy(
     ze_event_handle_t hEvent) {
     return L0::Event::fromHandle(hEvent)->destroy();
 }
 
-ze_result_t zeEventPoolGetIpcHandle(
+ze_result_t ZE_APICALL zeEventPoolGetIpcHandle(
     ze_event_pool_handle_t hEventPool,
     ze_ipc_event_pool_handle_t *phIpc) {
     return L0::EventPool::fromHandle(hEventPool)->getIpcHandle(phIpc);
 }
 
-ze_result_t zeEventPoolOpenIpcHandle(
+ze_result_t ZE_APICALL zeEventPoolOpenIpcHandle(
     ze_context_handle_t hContext,
     ze_ipc_event_pool_handle_t hIpc,
     ze_event_pool_handle_t *phEventPool) {
     return L0::Context::fromHandle(hContext)->openEventPoolIpcHandle(hIpc, phEventPool);
 }
 
-ze_result_t zeEventPoolCloseIpcHandle(
+ze_result_t ZE_APICALL zeEventPoolCloseIpcHandle(
     ze_event_pool_handle_t hEventPool) {
     return L0::EventPool::fromHandle(hEventPool)->closeIpcHandle();
 }
 
-ze_result_t zeCommandListAppendSignalEvent(
+ze_result_t ZE_APICALL zeCommandListAppendSignalEvent(
     ze_command_list_handle_t hCommandList,
     ze_event_handle_t hEvent) {
     auto cmdList = L0::CommandList::fromHandle(hCommandList);
@@ -69,7 +69,7 @@ ze_result_t zeCommandListAppendSignalEvent(
     return cmdList->appendSignalEvent(hEvent, false);
 }
 
-ze_result_t zeCommandListAppendWaitOnEvents(
+ze_result_t ZE_APICALL zeCommandListAppendWaitOnEvents(
     ze_command_list_handle_t hCommandList,
     uint32_t numEvents,
     ze_event_handle_t *phEvents) {
@@ -82,23 +82,23 @@ ze_result_t zeCommandListAppendWaitOnEvents(
     return cmdList->appendWaitOnEvents(numEvents, phEvents, nullptr, false, true, true, false, false, false);
 }
 
-ze_result_t zeEventHostSignal(
+ze_result_t ZE_APICALL zeEventHostSignal(
     ze_event_handle_t hEvent) {
     return L0::Event::fromHandle(hEvent)->hostSignal(false);
 }
 
-ze_result_t zeEventHostSynchronize(
+ze_result_t ZE_APICALL zeEventHostSynchronize(
     ze_event_handle_t hEvent,
     uint64_t timeout) {
     return L0::Event::fromHandle(hEvent)->hostSynchronize(timeout);
 }
 
-ze_result_t zeEventQueryStatus(
+ze_result_t ZE_APICALL zeEventQueryStatus(
     ze_event_handle_t hEvent) {
     return L0::Event::fromHandle(hEvent)->queryStatus();
 }
 
-ze_result_t zeCommandListAppendEventReset(
+ze_result_t ZE_APICALL zeCommandListAppendEventReset(
     ze_command_list_handle_t hCommandList,
     ze_event_handle_t hEvent) {
     auto cmdList = L0::CommandList::fromHandle(hCommandList);
@@ -110,18 +110,18 @@ ze_result_t zeCommandListAppendEventReset(
     return cmdList->appendEventReset(hEvent);
 }
 
-ze_result_t zeEventHostReset(
+ze_result_t ZE_APICALL zeEventHostReset(
     ze_event_handle_t hEvent) {
     return L0::Event::fromHandle(hEvent)->reset();
 }
 
-ze_result_t zeEventQueryKernelTimestamp(
+ze_result_t ZE_APICALL zeEventQueryKernelTimestamp(
     ze_event_handle_t hEvent,
     ze_kernel_timestamp_result_t *timestampType) {
     return L0::Event::fromHandle(hEvent)->queryKernelTimestamp(timestampType);
 }
 
-ze_result_t zeEventQueryKernelTimestampsExt(
+ze_result_t ZE_APICALL zeEventQueryKernelTimestampsExt(
     ze_event_handle_t hEvent,
     ze_device_handle_t hDevice,
     uint32_t *pCount,
@@ -129,37 +129,37 @@ ze_result_t zeEventQueryKernelTimestampsExt(
     return L0::Event::fromHandle(hEvent)->queryKernelTimestampsExt(L0::Device::fromHandle(hDevice), pCount, pResults);
 }
 
-ze_result_t zeEventPoolPutIpcHandle(
+ze_result_t ZE_APICALL zeEventPoolPutIpcHandle(
     ze_context_handle_t hContext,
     ze_ipc_event_pool_handle_t hIpc) {
     return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
 }
 
-ze_result_t zeEventPoolGetContextHandle(
+ze_result_t ZE_APICALL zeEventPoolGetContextHandle(
     ze_event_pool_handle_t hEventPool,
     ze_context_handle_t *phContext) {
     return L0::EventPool::fromHandle(hEventPool)->getContextHandle(phContext);
 }
 
-ze_result_t zeEventPoolGetFlags(
+ze_result_t ZE_APICALL zeEventPoolGetFlags(
     ze_event_pool_handle_t hEventPool,
     ze_event_pool_flags_t *pFlags) {
     return L0::EventPool::fromHandle(hEventPool)->getFlags(pFlags);
 }
 
-ze_result_t zeEventGetEventPool(
+ze_result_t ZE_APICALL zeEventGetEventPool(
     ze_event_handle_t hEvent,
     ze_event_pool_handle_t *phEventPool) {
     return L0::Event::fromHandle(hEvent)->getEventPool(phEventPool);
 }
 
-ze_result_t zeEventGetSignalScope(
+ze_result_t ZE_APICALL zeEventGetSignalScope(
     ze_event_handle_t hEvent,
     ze_event_scope_flags_t *pSignalScope) {
     return L0::Event::fromHandle(hEvent)->getSignalScope(pSignalScope);
 }
 
-ze_result_t zeEventGetWaitScope(
+ze_result_t ZE_APICALL zeEventGetWaitScope(
     ze_event_handle_t hEvent,
     ze_event_scope_flags_t *pWaitScope) {
     return L0::Event::fromHandle(hEvent)->getWaitScope(pWaitScope);

level_zero/api/core/ze_fence_api_entrypoints.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2020-2022 Intel Corporation
+ * Copyright (C) 2020-2025 Intel Corporation
  *
  * SPDX-License-Identifier: MIT
  *
@@ -11,30 +11,30 @@
 #include <level_zero/ze_api.h>
 
 namespace L0 {
-ze_result_t zeFenceCreate(
+ze_result_t ZE_APICALL zeFenceCreate(
     ze_command_queue_handle_t hCommandQueue,
     const ze_fence_desc_t *desc,
     ze_fence_handle_t *phFence) {
     return L0::CommandQueue::fromHandle(hCommandQueue)->createFence(desc, phFence);
 }
 
-ze_result_t zeFenceDestroy(
+ze_result_t ZE_APICALL zeFenceDestroy(
     ze_fence_handle_t hFence) {
     return L0::Fence::fromHandle(hFence)->destroy();
 }
 
-ze_result_t zeFenceHostSynchronize(
+ze_result_t ZE_APICALL zeFenceHostSynchronize(
     ze_fence_handle_t hFence,
     uint64_t timeout) {
     return L0::Fence::fromHandle(hFence)->hostSynchronize(timeout);
 }
 
-ze_result_t zeFenceQueryStatus(
+ze_result_t ZE_APICALL zeFenceQueryStatus(
     ze_fence_handle_t hFence) {
     return L0::Fence::fromHandle(hFence)->queryStatus();
 }
 
-ze_result_t zeFenceReset(
+ze_result_t ZE_APICALL zeFenceReset(
     ze_fence_handle_t hFence) {
     return L0::Fence::fromHandle(hFence)->reset(false);
 }

level_zero/api/core/ze_image_api_entrypoints.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2020-2022 Intel Corporation
+ * Copyright (C) 2020-2025 Intel Corporation
  *
  * SPDX-License-Identifier: MIT
  *
@@ -11,14 +11,14 @@
 #include <level_zero/ze_api.h>
 
 namespace L0 {
-ze_result_t zeImageGetProperties(
+ze_result_t ZE_APICALL zeImageGetProperties(
     ze_device_handle_t hDevice,
     const ze_image_desc_t *desc,
     ze_image_properties_t *pImageProperties) {
     return L0::Device::fromHandle(hDevice)->imageGetProperties(desc, pImageProperties);
 }
 
-ze_result_t zeImageCreate(
+ze_result_t ZE_APICALL zeImageCreate(
     ze_context_handle_t hContext,
     ze_device_handle_t hDevice,
     const ze_image_desc_t *desc,
@@ -26,7 +26,7 @@ ze_result_t zeImageCreate(
     return L0::Context::fromHandle(hContext)->createImage(hDevice, desc, phImage);
 }
 
-ze_result_t zeImageDestroy(
+ze_result_t ZE_APICALL zeImageDestroy(
     ze_image_handle_t hImage) {
     return L0::Image::fromHandle(hImage)->destroy();
 }

level_zero/api/core/ze_memory_api_entrypoints.h

@@ -11,7 +11,7 @@
 #include <level_zero/ze_api.h>
 
 namespace L0 {
-ze_result_t zeMemAllocShared(
+ze_result_t ZE_APICALL zeMemAllocShared(
     ze_context_handle_t hContext,
     const ze_device_mem_alloc_desc_t *deviceDesc,
     const ze_host_mem_alloc_desc_t *hostDesc,
@@ -22,7 +22,7 @@ ze_result_t zeMemAllocShared(
     return L0::Context::fromHandle(hContext)->allocSharedMem(hDevice, deviceDesc, hostDesc, size, alignment, pptr);
 }
 
-ze_result_t zeMemAllocDevice(
+ze_result_t ZE_APICALL zeMemAllocDevice(
     ze_context_handle_t hContext,
     const ze_device_mem_alloc_desc_t *deviceDesc,
     size_t size,
@@ -32,7 +32,7 @@ ze_result_t zeMemAllocDevice(
     return L0::Context::fromHandle(hContext)->allocDeviceMem(hDevice, deviceDesc, size, alignment, pptr);
 }
 
-ze_result_t zeMemAllocHost(
+ze_result_t ZE_APICALL zeMemAllocHost(
     ze_context_handle_t hContext,
     const ze_host_mem_alloc_desc_t *hostDesc,
     size_t size,
@@ -41,20 +41,20 @@ ze_result_t zeMemAllocHost(
     return L0::Context::fromHandle(hContext)->allocHostMem(hostDesc, size, alignment, pptr);
 }
 
-ze_result_t zeMemFree(
+ze_result_t ZE_APICALL zeMemFree(
     ze_context_handle_t hContext,
     void *ptr) {
     return L0::Context::fromHandle(hContext)->freeMem(ptr);
 }
 
-ze_result_t zeMemFreeExt(
+ze_result_t ZE_APICALL zeMemFreeExt(
     ze_context_handle_t hContext,
     const ze_memory_free_ext_desc_t *pMemFreeDesc,
     void *ptr) {
     return L0::Context::fromHandle(hContext)->freeMemExt(pMemFreeDesc, ptr);
 }
 
-ze_result_t zeMemGetAllocProperties(
+ze_result_t ZE_APICALL zeMemGetAllocProperties(
     ze_context_handle_t hContext,
     const void *ptr,
     ze_memory_allocation_properties_t *pMemAllocProperties,
@@ -62,7 +62,7 @@ ze_result_t zeMemGetAllocProperties(
     return L0::Context::fromHandle(hContext)->getMemAllocProperties(ptr, pMemAllocProperties, phDevice);
 }
 
-ze_result_t zeMemGetAddressRange(
+ze_result_t ZE_APICALL zeMemGetAddressRange(
     ze_context_handle_t hContext,
     const void *ptr,
     void **pBase,
@@ -70,20 +70,20 @@ ze_result_t zeMemGetAddressRange(
     return L0::Context::fromHandle(hContext)->getMemAddressRange(ptr, pBase, pSize);
 }
 
-ze_result_t zeMemGetIpcHandle(
+ze_result_t ZE_APICALL zeMemGetIpcHandle(
     ze_context_handle_t hContext,
     const void *ptr,
     ze_ipc_mem_handle_t *pIpcHandle) {
     return L0::Context::fromHandle(hContext)->getIpcMemHandle(ptr, pIpcHandle);
 }
 
-ze_result_t zeMemPutIpcHandle(
+ze_result_t ZE_APICALL zeMemPutIpcHandle(
     ze_context_handle_t hContext,
     ze_ipc_mem_handle_t ipcHandle) {
     return L0::Context::fromHandle(hContext)->putIpcMemHandle(ipcHandle);
 }
 
-ze_result_t zeMemOpenIpcHandle(
+ze_result_t ZE_APICALL zeMemOpenIpcHandle(
     ze_context_handle_t hContext,
     ze_device_handle_t hDevice,
     ze_ipc_mem_handle_t handle,
@@ -92,17 +92,17 @@ ze_result_t zeMemOpenIpcHandle(
     return L0::Context::fromHandle(hContext)->openIpcMemHandle(hDevice, handle, flags, pptr);
 }
 
-ze_result_t zeMemCloseIpcHandle(
+ze_result_t ZE_APICALL zeMemCloseIpcHandle(
     ze_context_handle_t hContext,
     const void *ptr) {
     return L0::Context::fromHandle(hContext)->closeIpcMemHandle(ptr);
 }
 
-ze_result_t zeMemGetIpcHandleFromFileDescriptorExp(ze_context_handle_t hContext, uint64_t handle, ze_ipc_mem_handle_t *pIpcHandle) {
+ze_result_t ZE_APICALL zeMemGetIpcHandleFromFileDescriptorExp(ze_context_handle_t hContext, uint64_t handle, ze_ipc_mem_handle_t *pIpcHandle) {
     return L0::Context::fromHandle(hContext)->getIpcHandleFromFd(handle, pIpcHandle);
 }
 
-ze_result_t zeMemGetFileDescriptorFromIpcHandleExp(ze_context_handle_t hContext, ze_ipc_mem_handle_t ipcHandle, uint64_t *pHandle) {
+ze_result_t ZE_APICALL zeMemGetFileDescriptorFromIpcHandleExp(ze_context_handle_t hContext, ze_ipc_mem_handle_t ipcHandle, uint64_t *pHandle) {
     return L0::Context::fromHandle(hContext)->getFdFromIpcHandle(ipcHandle, pHandle);
 }
 

level_zero/api/core/ze_module_api_entrypoints.h

@@ -17,7 +17,7 @@
 #include "graph_captured_apis.h"
 
 namespace L0 {
-ze_result_t zeModuleCreate(
+ze_result_t ZE_APICALL zeModuleCreate(
     ze_context_handle_t hContext,
     ze_device_handle_t hDevice,
     const ze_module_desc_t *desc,
@@ -26,31 +26,31 @@ ze_result_t zeModuleCreate(
     return L0::Context::fromHandle(hContext)->createModule(hDevice, desc, phModule, phBuildLog);
 }
 
-ze_result_t zeModuleDestroy(
+ze_result_t ZE_APICALL zeModuleDestroy(
     ze_module_handle_t hModule) {
     return L0::Module::fromHandle(hModule)->destroy();
 }
 
-ze_result_t zeModuleBuildLogDestroy(
+ze_result_t ZE_APICALL zeModuleBuildLogDestroy(
     ze_module_build_log_handle_t hModuleBuildLog) {
     return L0::ModuleBuildLog::fromHandle(hModuleBuildLog)->destroy();
 }
 
-ze_result_t zeModuleBuildLogGetString(
+ze_result_t ZE_APICALL zeModuleBuildLogGetString(
     ze_module_build_log_handle_t hModuleBuildLog,
     size_t *pSize,
     char *pBuildLog) {
     return L0::ModuleBuildLog::fromHandle(hModuleBuildLog)->getString(pSize, pBuildLog);
 }
 
-ze_result_t zeModuleGetNativeBinary(
+ze_result_t ZE_APICALL zeModuleGetNativeBinary(
     ze_module_handle_t hModule,
     size_t *pSize,
     uint8_t *pModuleNativeBinary) {
     return L0::Module::fromHandle(hModule)->getNativeBinary(pSize, pModuleNativeBinary);
 }
 
-ze_result_t zeModuleGetGlobalPointer(
+ze_result_t ZE_APICALL zeModuleGetGlobalPointer(
     ze_module_handle_t hModule,
     const char *pGlobalName,
     size_t *pSize,
@@ -58,33 +58,33 @@ ze_result_t zeModuleGetGlobalPointer(
     return L0::Module::fromHandle(hModule)->getGlobalPointer(pGlobalName, pSize, pptr);
 }
 
-ze_result_t zeModuleGetKernelNames(
+ze_result_t ZE_APICALL zeModuleGetKernelNames(
     ze_module_handle_t hModule,
     uint32_t *pCount,
     const char **pNames) {
     return L0::Module::fromHandle(hModule)->getKernelNames(pCount, pNames);
 }
 
-ze_result_t zeKernelCreate(
+ze_result_t ZE_APICALL zeKernelCreate(
     ze_module_handle_t hModule,
     const ze_kernel_desc_t *desc,
     ze_kernel_handle_t *kernelHandle) {
     return L0::Module::fromHandle(hModule)->createKernel(desc, kernelHandle);
 }
 
-ze_result_t zeKernelDestroy(
+ze_result_t ZE_APICALL zeKernelDestroy(
     ze_kernel_handle_t hKernel) {
     return L0::Kernel::fromHandle(hKernel)->destroy();
 }
 
-ze_result_t zeModuleGetFunctionPointer(
+ze_result_t ZE_APICALL zeModuleGetFunctionPointer(
     ze_module_handle_t hModule,
     const char *pKernelName,
     void **pfnFunction) {
     return L0::Module::fromHandle(hModule)->getFunctionPointer(pKernelName, pfnFunction);
 }
 
-ze_result_t zeKernelSetGroupSize(
+ze_result_t ZE_APICALL zeKernelSetGroupSize(
     ze_kernel_handle_t hKernel,
     uint32_t groupSizeX,
     uint32_t groupSizeY,
@@ -92,7 +92,7 @@ ze_result_t zeKernelSetGroupSize(
     return L0::Kernel::fromHandle(hKernel)->setGroupSize(groupSizeX, groupSizeY, groupSizeZ);
 }
 
-ze_result_t zeKernelSuggestGroupSize(
+ze_result_t ZE_APICALL zeKernelSuggestGroupSize(
     ze_kernel_handle_t hKernel,
     uint32_t globalSizeX,
     uint32_t globalSizeY,
@@ -103,14 +103,14 @@ ze_result_t zeKernelSuggestGroupSize(
     return L0::Kernel::fromHandle(hKernel)->suggestGroupSize(globalSizeX, globalSizeY, globalSizeZ, groupSizeX, groupSizeY, groupSizeZ);
 }
 
-ze_result_t zeKernelSuggestMaxCooperativeGroupCount(
+ze_result_t ZE_APICALL zeKernelSuggestMaxCooperativeGroupCount(
     ze_kernel_handle_t hKernel,
     uint32_t *totalGroupCount) {
     *totalGroupCount = L0::Kernel::fromHandle(hKernel)->suggestMaxCooperativeGroupCount(NEO::EngineGroupType::compute, false);
     return ZE_RESULT_SUCCESS;
 }
 
-ze_result_t zeKernelSetArgumentValue(
+ze_result_t ZE_APICALL zeKernelSetArgumentValue(
     ze_kernel_handle_t hKernel,
     uint32_t argIndex,
     size_t argSize,
@@ -118,39 +118,39 @@ ze_result_t zeKernelSetArgumentValue(
     return L0::Kernel::fromHandle(hKernel)->setArgumentValue(argIndex, argSize, pArgValue);
 }
 
-ze_result_t zeKernelSetIndirectAccess(
+ze_result_t ZE_APICALL zeKernelSetIndirectAccess(
     ze_kernel_handle_t hKernel,
     ze_kernel_indirect_access_flags_t flags) {
     return L0::Kernel::fromHandle(hKernel)->setIndirectAccess(flags);
 }
 
-ze_result_t zeKernelGetIndirectAccess(
+ze_result_t ZE_APICALL zeKernelGetIndirectAccess(
     ze_kernel_handle_t hKernel,
     ze_kernel_indirect_access_flags_t *pFlags) {
     return L0::Kernel::fromHandle(hKernel)->getIndirectAccess(pFlags);
 }
 
-ze_result_t zeKernelGetSourceAttributes(
+ze_result_t ZE_APICALL zeKernelGetSourceAttributes(
     ze_kernel_handle_t hKernel,
     uint32_t *pSize,
     char **pString) {
     return L0::Kernel::fromHandle(hKernel)->getSourceAttributes(pSize, pString);
 }
 
-ze_result_t zeKernelGetProperties(
+ze_result_t ZE_APICALL zeKernelGetProperties(
     ze_kernel_handle_t hKernel,
     ze_kernel_properties_t *pKernelProperties) {
     return L0::Kernel::fromHandle(hKernel)->getProperties(pKernelProperties);
 }
 
-ze_result_t zeKernelGetBinaryExp(
+ze_result_t ZE_APICALL zeKernelGetBinaryExp(
     ze_kernel_handle_t hKernel,
     size_t *pSize,
     uint8_t *pKernelBinary) {
     return L0::Kernel::fromHandle(hKernel)->getKernelProgramBinary(pSize, reinterpret_cast<char *>(pKernelBinary));
 }
 
-ze_result_t zeCommandListAppendLaunchKernel(
+ze_result_t ZE_APICALL zeCommandListAppendLaunchKernel(
     ze_command_list_handle_t hCommandList,
     ze_kernel_handle_t kernelHandle,
     const ze_group_count_t *launchKernelArgs,
@@ -170,7 +170,7 @@ ze_result_t zeCommandListAppendLaunchKernel(
     return cmdList->appendLaunchKernel(kernelHandle, *launchKernelArgs, hSignalEvent, numWaitEvents, phWaitEvents, launchParams);
 }
 
-ze_result_t zeCommandListAppendLaunchCooperativeKernel(
+ze_result_t ZE_APICALL zeCommandListAppendLaunchCooperativeKernel(
     ze_command_list_handle_t hCommandList,
     ze_kernel_handle_t kernelHandle,
     const ze_group_count_t *launchKernelArgs,
@@ -190,7 +190,7 @@ ze_result_t zeCommandListAppendLaunchCooperativeKernel(
     return L0::CommandList::fromHandle(hCommandList)->appendLaunchKernel(kernelHandle, *launchKernelArgs, hSignalEvent, numWaitEvents, phWaitEvents, launchParams);
 }
 
-ze_result_t zeCommandListAppendLaunchKernelIndirect(
+ze_result_t ZE_APICALL zeCommandListAppendLaunchKernelIndirect(
     ze_command_list_handle_t hCommandList,
     ze_kernel_handle_t kernelHandle,
     const ze_group_count_t *pLaunchArgumentsBuffer,
@@ -207,7 +207,7 @@ ze_result_t zeCommandListAppendLaunchKernelIndirect(
     return L0::CommandList::fromHandle(hCommandList)->appendLaunchKernelIndirect(kernelHandle, *pLaunchArgumentsBuffer, hSignalEvent, numWaitEvents, phWaitEvents, false);
 }
 
-ze_result_t zeCommandListAppendLaunchMultipleKernelsIndirect(
+ze_result_t ZE_APICALL zeCommandListAppendLaunchMultipleKernelsIndirect(
     ze_command_list_handle_t hCommandList,
     uint32_t numKernels,
     ze_kernel_handle_t *kernelHandles,
@@ -226,27 +226,27 @@ ze_result_t zeCommandListAppendLaunchMultipleKernelsIndirect(
     return L0::CommandList::fromHandle(hCommandList)->appendLaunchMultipleKernelsIndirect(numKernels, kernelHandles, pCountBuffer, pLaunchArgumentsBuffer, hSignalEvent, numWaitEvents, phWaitEvents, false);
 }
 
-ze_result_t zeKernelGetName(
+ze_result_t ZE_APICALL zeKernelGetName(
     ze_kernel_handle_t hKernel,
     size_t *pSize,
     char *pName) {
     return L0::Kernel::fromHandle(hKernel)->getKernelName(pSize, pName);
 }
 
-ze_result_t zeModuleDynamicLink(
+ze_result_t ZE_APICALL zeModuleDynamicLink(
     uint32_t numModules,
     ze_module_handle_t *phModules,
     ze_module_build_log_handle_t *phLinkLog) {
     return L0::Module::fromHandle(phModules[0])->performDynamicLink(numModules, phModules, phLinkLog);
 }
 
-ze_result_t zeModuleGetProperties(
+ze_result_t ZE_APICALL zeModuleGetProperties(
     ze_module_handle_t hModule,
     ze_module_properties_t *pModuleProperties) {
     return L0::Module::fromHandle(hModule)->getProperties(pModuleProperties);
 }
 
-ze_result_t zeModuleInspectLinkageExt(
+ze_result_t ZE_APICALL zeModuleInspectLinkageExt(
     ze_linkage_inspection_ext_desc_t *pInspectDesc,
     uint32_t numModules,
     ze_module_handle_t *phModules,
@@ -254,19 +254,19 @@ ze_result_t zeModuleInspectLinkageExt(
     return L0::Module::fromHandle(phModules[0])->inspectLinkage(pInspectDesc, numModules, phModules, phLog);
 }
 
-ze_result_t zeKernelSetCacheConfig(
+ze_result_t ZE_APICALL zeKernelSetCacheConfig(
     ze_kernel_handle_t hKernel,
     ze_cache_config_flags_t flags) {
     return L0::Kernel::fromHandle(hKernel)->setCacheConfig(flags);
 }
 
-ze_result_t zeKernelSchedulingHintExp(
+ze_result_t ZE_APICALL zeKernelSchedulingHintExp(
     ze_kernel_handle_t hKernel,
     ze_scheduling_hint_exp_desc_t *pHint) {
     return L0::Kernel::fromHandle(hKernel)->setSchedulingHintExp(pHint);
 }
 
-ze_result_t zeKernelGetAllocationPropertiesExp(
+ze_result_t ZE_APICALL zeKernelGetAllocationPropertiesExp(
     ze_kernel_handle_t hKernel,
     uint32_t *pCount,
     ze_kernel_allocation_exp_properties_t *pAllocationProperties) {

level_zero/api/core/ze_sampler_api_entrypoints.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2020-2022 Intel Corporation
+ * Copyright (C) 2020-2025 Intel Corporation
  *
  * SPDX-License-Identifier: MIT
  *
@@ -12,7 +12,7 @@
 #include <level_zero/ze_api.h>
 
 namespace L0 {
-ze_result_t zeSamplerCreate(
+ze_result_t ZE_APICALL zeSamplerCreate(
     ze_context_handle_t hContext,
     ze_device_handle_t hDevice,
     const ze_sampler_desc_t *desc,
@@ -20,7 +20,7 @@ ze_result_t zeSamplerCreate(
     return L0::Context::fromHandle(hContext)->createSampler(hDevice, desc, phSampler);
 }
 
-ze_result_t zeSamplerDestroy(
+ze_result_t ZE_APICALL zeSamplerDestroy(
     ze_sampler_handle_t hSampler) {
     return L0::Sampler::fromHandle(hSampler)->destroy();
 }

level_zero/api/runtime/ze_runtime_all_api_entrypoints.h

@@ -14,15 +14,15 @@
 #include <level_zero/zer_api.h>
 
 namespace L0 {
-ze_context_handle_t zerGetDefaultContext() {
+ze_context_handle_t ZE_APICALL zerGetDefaultContext() {
     return L0::DriverHandle::fromHandle(L0::globalDriverHandles->front())->getDefaultContext();
 }
 
-ze_result_t zerGetLastErrorDescription(const char **ppString) {
+ze_result_t ZE_APICALL zerGetLastErrorDescription(const char **ppString) {
     return L0::DriverHandle::fromHandle(L0::globalDriverHandles->front())->getErrorDescription(ppString);
 }
 
-uint32_t zerTranslateDeviceHandleToIdentifier(ze_device_handle_t device) {
+uint32_t ZE_APICALL zerTranslateDeviceHandleToIdentifier(ze_device_handle_t device) {
     if (!device) {
         auto driverHandle = static_cast<L0::DriverHandleImp *>(L0::globalDriverHandles->front());
         driverHandle->setErrorDescription("Invalid device handle");
@@ -31,7 +31,7 @@ uint32_t zerTranslateDeviceHandleToIdentifier(ze_device_handle_t device) {
     return L0::Device::fromHandle(device)->getIdentifier();
 }
 
-ze_device_handle_t zerTranslateIdentifierToDeviceHandle(uint32_t identifier) {
+ze_device_handle_t ZE_APICALL zerTranslateIdentifierToDeviceHandle(uint32_t identifier) {
     auto driverHandle = static_cast<L0::DriverHandleImp *>(L0::globalDriverHandles->front());
     if (identifier >= driverHandle->devicesToExpose.size()) {
         driverHandle->setErrorDescription("Invalid device identifier");

level_zero/api/tools/zet_debug_api_entrypoints.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2020-2023 Intel Corporation
+ * Copyright (C) 2020-2025 Intel Corporation
  *
  * SPDX-License-Identifier: MIT
  *
@@ -12,44 +12,44 @@
 #include <level_zero/zet_api.h>
 
 namespace L0 {
-ze_result_t zetDeviceGetDebugProperties(
+ze_result_t ZE_APICALL zetDeviceGetDebugProperties(
     zet_device_handle_t hDevice,
     zet_device_debug_properties_t *pDebugProperties) {
     return L0::Device::fromHandle(hDevice)->getDebugProperties(pDebugProperties);
 }
 
-ze_result_t zetDebugAttach(
+ze_result_t ZE_APICALL zetDebugAttach(
     zet_device_handle_t hDevice,
     const zet_debug_config_t *config,
     zet_debug_session_handle_t *phDebug) {
     return L0::DebugApiHandlers::debugAttach(hDevice, config, phDebug);
 }
 
-ze_result_t zetDebugDetach(
+ze_result_t ZE_APICALL zetDebugDetach(
     zet_debug_session_handle_t hDebug) {
     return L0::DebugApiHandlers::debugDetach(hDebug);
 }
 
-ze_result_t zetDebugReadEvent(
+ze_result_t ZE_APICALL zetDebugReadEvent(
     zet_debug_session_handle_t hDebug,
     uint64_t timeout,
     zet_debug_event_t *event) {
     return L0::DebugApiHandlers::debugReadEvent(hDebug, timeout, event);
 }
 
-ze_result_t zetDebugInterrupt(
+ze_result_t ZE_APICALL zetDebugInterrupt(
     zet_debug_session_handle_t hDebug,
     ze_device_thread_t thread) {
     return L0::DebugApiHandlers::debugInterrupt(hDebug, thread);
 }
 
-ze_result_t zetDebugResume(
+ze_result_t ZE_APICALL zetDebugResume(
     zet_debug_session_handle_t hDebug,
     ze_device_thread_t thread) {
     return L0::DebugApiHandlers::debugResume(hDebug, thread);
 }
 
-ze_result_t zetDebugReadMemory(
+ze_result_t ZE_APICALL zetDebugReadMemory(
     zet_debug_session_handle_t hDebug,
     ze_device_thread_t thread,
     const zet_debug_memory_space_desc_t *desc,
@@ -58,7 +58,7 @@ ze_result_t zetDebugReadMemory(
     return L0::DebugApiHandlers::debugReadMemory(hDebug, thread, desc, size, buffer);
 }
 
-ze_result_t zetDebugWriteMemory(
+ze_result_t ZE_APICALL zetDebugWriteMemory(
     zet_debug_session_handle_t hDebug,
     ze_device_thread_t thread,
     const zet_debug_memory_space_desc_t *desc,
@@ -67,20 +67,20 @@ ze_result_t zetDebugWriteMemory(
     return L0::DebugApiHandlers::debugWriteMemory(hDebug, thread, desc, size, buffer);
 }
 
-ze_result_t zetDebugAcknowledgeEvent(
+ze_result_t ZE_APICALL zetDebugAcknowledgeEvent(
     zet_debug_session_handle_t hDebug,
     const zet_debug_event_t *event) {
     return L0::DebugApiHandlers::debugAcknowledgeEvent(hDebug, event);
 }
 
-ze_result_t zetDebugGetRegisterSetProperties(
+ze_result_t ZE_APICALL zetDebugGetRegisterSetProperties(
     zet_device_handle_t hDevice,
     uint32_t *pCount,
     zet_debug_regset_properties_t *pRegisterSetProperties) {
     return L0::DebugApiHandlers::debugGetRegisterSetProperties(hDevice, pCount, pRegisterSetProperties);
 }
 
-ze_result_t zetDebugReadRegisters(
+ze_result_t ZE_APICALL zetDebugReadRegisters(
     zet_debug_session_handle_t hDebug,
     ze_device_thread_t thread,
     uint32_t type,
@@ -90,7 +90,7 @@ ze_result_t zetDebugReadRegisters(
     return L0::DebugApiHandlers::debugReadRegisters(hDebug, thread, type, start, count, pRegisterValues);
 }
 
-ze_result_t zetDebugWriteRegisters(
+ze_result_t ZE_APICALL zetDebugWriteRegisters(
     zet_debug_session_handle_t hDebug,
     ze_device_thread_t thread,
     uint32_t type,
@@ -100,7 +100,7 @@ ze_result_t zetDebugWriteRegisters(
     return L0::DebugApiHandlers::debugWriteRegisters(hDebug, thread, type, start, count, pRegisterValues);
 }
 
-ze_result_t zetDebugGetThreadRegisterSetProperties(
+ze_result_t ZE_APICALL zetDebugGetThreadRegisterSetProperties(
     zet_debug_session_handle_t hDebug,
     ze_device_thread_t thread,
     uint32_t *pCount,

level_zero/api/tools/zet_metric_api_entrypoints.h

@@ -15,33 +15,33 @@
 
 namespace L0 {
 
-ze_result_t zetMetricGroupGet(
+ze_result_t ZE_APICALL zetMetricGroupGet(
     zet_device_handle_t hDevice,
     uint32_t *pCount,
     zet_metric_group_handle_t *phMetricGroups) {
     return L0::metricGroupGet(hDevice, pCount, phMetricGroups);
 }
 
-ze_result_t zetMetricGroupGetProperties(
+ze_result_t ZE_APICALL zetMetricGroupGetProperties(
     zet_metric_group_handle_t hMetricGroup,
     zet_metric_group_properties_t *pProperties) {
     return L0::MetricGroup::fromHandle(hMetricGroup)->getProperties(pProperties);
 }
 
-ze_result_t zetMetricGet(
+ze_result_t ZE_APICALL zetMetricGet(
     zet_metric_group_handle_t hMetricGroup,
     uint32_t *pCount,
     zet_metric_handle_t *phMetrics) {
     return L0::MetricGroup::fromHandle(hMetricGroup)->metricGet(pCount, phMetrics);
 }
 
-ze_result_t zetMetricGetProperties(
+ze_result_t ZE_APICALL zetMetricGetProperties(
     zet_metric_handle_t hMetric,
     zet_metric_properties_t *pProperties) {
     return L0::Metric::fromHandle(hMetric)->getProperties(pProperties);
 }
 
-ze_result_t zetMetricGroupCalculateMetricValues(
+ze_result_t ZE_APICALL zetMetricGroupCalculateMetricValues(
     zet_metric_group_handle_t hMetricGroup,
     zet_metric_group_calculation_type_t type,
     size_t rawDataSize,
@@ -51,7 +51,7 @@ ze_result_t zetMetricGroupCalculateMetricValues(
     return L0::MetricGroup::fromHandle(hMetricGroup)->calculateMetricValues(type, rawDataSize, pRawData, pMetricValueCount, pMetricValues);
 }
 
-ze_result_t zetContextActivateMetricGroups(
+ze_result_t ZE_APICALL zetContextActivateMetricGroups(
     zet_context_handle_t hContext,
     zet_device_handle_t hDevice,
     uint32_t count,
@@ -59,7 +59,7 @@ ze_result_t zetContextActivateMetricGroups(
     return L0::Context::fromHandle(hContext)->activateMetricGroups(hDevice, count, phMetricGroups);
 }
 
-ze_result_t zetMetricStreamerOpen(
+ze_result_t ZE_APICALL zetMetricStreamerOpen(
     zet_context_handle_t hContext,
     zet_device_handle_t hDevice,
     zet_metric_group_handle_t hMetricGroup,
@@ -69,19 +69,19 @@ ze_result_t zetMetricStreamerOpen(
     return L0::metricStreamerOpen(hContext, hDevice, hMetricGroup, pDesc, hNotificationEvent, phMetricStreamer);
 }
 
-ze_result_t zetCommandListAppendMetricStreamerMarker(
+ze_result_t ZE_APICALL zetCommandListAppendMetricStreamerMarker(
     ze_command_list_handle_t hCommandList,
     zet_metric_streamer_handle_t hMetricStreamer,
     uint32_t value) {
     return L0::CommandList::fromHandle(hCommandList)->appendMetricStreamerMarker(hMetricStreamer, value);
 }
 
-ze_result_t zetMetricStreamerClose(
+ze_result_t ZE_APICALL zetMetricStreamerClose(
     zet_metric_streamer_handle_t hMetricStreamer) {
     return L0::MetricStreamer::fromHandle(hMetricStreamer)->close();
 }
 
-ze_result_t zetMetricStreamerReadData(
+ze_result_t ZE_APICALL zetMetricStreamerReadData(
     zet_metric_streamer_handle_t hMetricStreamer,
     uint32_t maxReportCount,
     size_t *pRawDataSize,
@@ -89,7 +89,7 @@ ze_result_t zetMetricStreamerReadData(
     return L0::MetricStreamer::fromHandle(hMetricStreamer)->readData(maxReportCount, pRawDataSize, pRawData);
 }
 
-ze_result_t zetMetricQueryPoolCreate(
+ze_result_t ZE_APICALL zetMetricQueryPoolCreate(
     zet_context_handle_t hContext,
     zet_device_handle_t hDevice,
     zet_metric_group_handle_t hMetricGroup,
@@ -98,35 +98,35 @@ ze_result_t zetMetricQueryPoolCreate(
     return L0::metricQueryPoolCreate(hContext, hDevice, hMetricGroup, desc, phMetricQueryPool);
 }
 
-ze_result_t zetMetricQueryPoolDestroy(
+ze_result_t ZE_APICALL zetMetricQueryPoolDestroy(
     zet_metric_query_pool_handle_t hMetricQueryPool) {
     return L0::MetricQueryPool::fromHandle(hMetricQueryPool)->destroy();
 }
 
-ze_result_t zetMetricQueryCreate(
+ze_result_t ZE_APICALL zetMetricQueryCreate(
     zet_metric_query_pool_handle_t hMetricQueryPool,
     uint32_t index,
     zet_metric_query_handle_t *phMetricQuery) {
     return L0::MetricQueryPool::fromHandle(hMetricQueryPool)->metricQueryCreate(index, phMetricQuery);
 }
 
-ze_result_t zetMetricQueryDestroy(
+ze_result_t ZE_APICALL zetMetricQueryDestroy(
     zet_metric_query_handle_t hMetricQuery) {
     return L0::MetricQuery::fromHandle(hMetricQuery)->destroy();
 }
 
-ze_result_t zetMetricQueryReset(
+ze_result_t ZE_APICALL zetMetricQueryReset(
     zet_metric_query_handle_t hMetricQuery) {
     return L0::MetricQuery::fromHandle(hMetricQuery)->reset();
 }
 
-ze_result_t zetCommandListAppendMetricQueryBegin(
+ze_result_t ZE_APICALL zetCommandListAppendMetricQueryBegin(
     zet_command_list_handle_t hCommandList,
     zet_metric_query_handle_t hMetricQuery) {
     return L0::CommandList::fromHandle(hCommandList)->appendMetricQueryBegin(hMetricQuery);
 }
 
-ze_result_t zetCommandListAppendMetricQueryEnd(
+ze_result_t ZE_APICALL zetCommandListAppendMetricQueryEnd(
     zet_command_list_handle_t hCommandList,
     zet_metric_query_handle_t hMetricQuery,
     ze_event_handle_t hSignalEvent,
@@ -135,12 +135,12 @@ ze_result_t zetCommandListAppendMetricQueryEnd(
     return L0::CommandList::fromHandle(hCommandList)->appendMetricQueryEnd(hMetricQuery, hSignalEvent, numWaitEvents, phWaitEvents);
 }
 
-ze_result_t zetCommandListAppendMetricMemoryBarrier(
+ze_result_t ZE_APICALL zetCommandListAppendMetricMemoryBarrier(
     zet_command_list_handle_t hCommandList) {
     return L0::CommandList::fromHandle(hCommandList)->appendMetricMemoryBarrier();
 }
 
-ze_result_t zetMetricQueryGetData(
+ze_result_t ZE_APICALL zetMetricQueryGetData(
     zet_metric_query_handle_t hMetricQuery,
     size_t *pRawDataSize,
     uint8_t *pRawData) {

level_zero/api/tools/zet_module_api_entrypoints.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2020-2022 Intel Corporation
+ * Copyright (C) 2020-2025 Intel Corporation
  *
  * SPDX-License-Identifier: MIT
  *
@@ -12,7 +12,7 @@
 #include <level_zero/zet_api.h>
 
 namespace L0 {
-ze_result_t zetModuleGetDebugInfo(
+ze_result_t ZE_APICALL zetModuleGetDebugInfo(
     zet_module_handle_t hModule,
     zet_module_debug_info_format_t format,
     size_t *pSize,
@@ -20,7 +20,7 @@ ze_result_t zetModuleGetDebugInfo(
     return L0::Module::fromHandle(hModule)->getDebugInfo(pSize, pDebugInfo);
 }
 
-ze_result_t zetKernelGetProfileInfo(
+ze_result_t ZE_APICALL zetKernelGetProfileInfo(
     zet_kernel_handle_t hKernel,
     zet_profile_properties_t *pProfileProperties) {
     return L0::Kernel::fromHandle(hKernel)->getProfileInfo(pProfileProperties);