| //===- Auto-generated file, part of the LLVM/Offload project --------------===// |
| // |
| // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. |
| // See https://llvm.org/LICENSE.txt for license information. |
| // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception |
| // |
| //===----------------------------------------------------------------------===// |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| llvm::Error olInit_val() { |
| if (offloadConfig().ValidationEnabled) { |
| } |
| |
| return llvm::offload::olInit_impl(); |
| } |
| OL_APIEXPORT ol_result_t OL_APICALL olInit() { |
| if (offloadConfig().TracingEnabled) { |
| llvm::errs() << "---> olInit"; |
| } |
| |
| ol_result_t Result = llvmErrorToOffloadError(olInit_val()); |
| |
| if (offloadConfig().TracingEnabled) { |
| llvm::errs() << "()"; |
| llvm::errs() << "-> " << Result << "\n"; |
| if (Result && Result->Details) { |
| llvm::errs() << " *Error Details* " << Result->Details << " \n"; |
| } |
| } |
| return Result; |
| } |
| ol_result_t olInitWithCodeLoc(ol_code_location_t *CodeLocation) { |
| currentCodeLocation() = CodeLocation; |
| ol_result_t Result = ::olInit(); |
| |
| currentCodeLocation() = nullptr; |
| return Result; |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| llvm::Error olShutDown_val() { |
| if (offloadConfig().ValidationEnabled) { |
| } |
| |
| return llvm::offload::olShutDown_impl(); |
| } |
| OL_APIEXPORT ol_result_t OL_APICALL olShutDown() { |
| if (offloadConfig().TracingEnabled) { |
| llvm::errs() << "---> olShutDown"; |
| } |
| |
| ol_result_t Result = llvmErrorToOffloadError(olShutDown_val()); |
| |
| if (offloadConfig().TracingEnabled) { |
| llvm::errs() << "()"; |
| llvm::errs() << "-> " << Result << "\n"; |
| if (Result && Result->Details) { |
| llvm::errs() << " *Error Details* " << Result->Details << " \n"; |
| } |
| } |
| return Result; |
| } |
| ol_result_t olShutDownWithCodeLoc(ol_code_location_t *CodeLocation) { |
| currentCodeLocation() = CodeLocation; |
| ol_result_t Result = ::olShutDown(); |
| |
| currentCodeLocation() = nullptr; |
| return Result; |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| llvm::Error olGetPlatformInfo_val(ol_platform_handle_t Platform, |
| ol_platform_info_t PropName, size_t PropSize, |
| void *PropValue) { |
| if (offloadConfig().ValidationEnabled) { |
| if (PropSize == 0) { |
| return createOffloadError(error::ErrorCode::INVALID_SIZE, |
| "validation failure: PropSize == 0"); |
| } |
| |
| if (NULL == Platform) { |
| return createOffloadError(error::ErrorCode::INVALID_NULL_HANDLE, |
| "validation failure: NULL == Platform"); |
| } |
| |
| if (NULL == PropValue) { |
| return createOffloadError(error::ErrorCode::INVALID_NULL_POINTER, |
| "validation failure: NULL == PropValue"); |
| } |
| } |
| |
| return llvm::offload::olGetPlatformInfo_impl(Platform, PropName, PropSize, |
| PropValue); |
| } |
| OL_APIEXPORT ol_result_t OL_APICALL |
| olGetPlatformInfo(ol_platform_handle_t Platform, ol_platform_info_t PropName, |
| size_t PropSize, void *PropValue) { |
| if (offloadConfig().TracingEnabled) { |
| llvm::errs() << "---> olGetPlatformInfo"; |
| } |
| |
| ol_result_t Result = llvmErrorToOffloadError( |
| olGetPlatformInfo_val(Platform, PropName, PropSize, PropValue)); |
| |
| if (offloadConfig().TracingEnabled) { |
| ol_get_platform_info_params_t Params = {&Platform, &PropName, &PropSize, |
| &PropValue}; |
| llvm::errs() << "(" << &Params << ")"; |
| llvm::errs() << "-> " << Result << "\n"; |
| if (Result && Result->Details) { |
| llvm::errs() << " *Error Details* " << Result->Details << " \n"; |
| } |
| } |
| return Result; |
| } |
| ol_result_t olGetPlatformInfoWithCodeLoc(ol_platform_handle_t Platform, |
| ol_platform_info_t PropName, |
| size_t PropSize, void *PropValue, |
| ol_code_location_t *CodeLocation) { |
| currentCodeLocation() = CodeLocation; |
| ol_result_t Result = |
| ::olGetPlatformInfo(Platform, PropName, PropSize, PropValue); |
| |
| currentCodeLocation() = nullptr; |
| return Result; |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| llvm::Error olGetPlatformInfoSize_val(ol_platform_handle_t Platform, |
| ol_platform_info_t PropName, |
| size_t *PropSizeRet) { |
| if (offloadConfig().ValidationEnabled) { |
| if (NULL == Platform) { |
| return createOffloadError(error::ErrorCode::INVALID_NULL_HANDLE, |
| "validation failure: NULL == Platform"); |
| } |
| |
| if (NULL == PropSizeRet) { |
| return createOffloadError(error::ErrorCode::INVALID_NULL_POINTER, |
| "validation failure: NULL == PropSizeRet"); |
| } |
| } |
| |
| return llvm::offload::olGetPlatformInfoSize_impl(Platform, PropName, |
| PropSizeRet); |
| } |
| OL_APIEXPORT ol_result_t OL_APICALL |
| olGetPlatformInfoSize(ol_platform_handle_t Platform, |
| ol_platform_info_t PropName, size_t *PropSizeRet) { |
| if (offloadConfig().TracingEnabled) { |
| llvm::errs() << "---> olGetPlatformInfoSize"; |
| } |
| |
| ol_result_t Result = llvmErrorToOffloadError( |
| olGetPlatformInfoSize_val(Platform, PropName, PropSizeRet)); |
| |
| if (offloadConfig().TracingEnabled) { |
| ol_get_platform_info_size_params_t Params = {&Platform, &PropName, |
| &PropSizeRet}; |
| llvm::errs() << "(" << &Params << ")"; |
| llvm::errs() << "-> " << Result << "\n"; |
| if (Result && Result->Details) { |
| llvm::errs() << " *Error Details* " << Result->Details << " \n"; |
| } |
| } |
| return Result; |
| } |
| ol_result_t olGetPlatformInfoSizeWithCodeLoc(ol_platform_handle_t Platform, |
| ol_platform_info_t PropName, |
| size_t *PropSizeRet, |
| ol_code_location_t *CodeLocation) { |
| currentCodeLocation() = CodeLocation; |
| ol_result_t Result = ::olGetPlatformInfoSize(Platform, PropName, PropSizeRet); |
| |
| currentCodeLocation() = nullptr; |
| return Result; |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| llvm::Error olIterateDevices_val(ol_device_iterate_cb_t Callback, |
| void *UserData) { |
| if (offloadConfig().ValidationEnabled) { |
| } |
| |
| return llvm::offload::olIterateDevices_impl(Callback, UserData); |
| } |
| OL_APIEXPORT ol_result_t OL_APICALL |
| olIterateDevices(ol_device_iterate_cb_t Callback, void *UserData) { |
| if (offloadConfig().TracingEnabled) { |
| llvm::errs() << "---> olIterateDevices"; |
| } |
| |
| ol_result_t Result = |
| llvmErrorToOffloadError(olIterateDevices_val(Callback, UserData)); |
| |
| if (offloadConfig().TracingEnabled) { |
| ol_iterate_devices_params_t Params = {&Callback, &UserData}; |
| llvm::errs() << "(" << &Params << ")"; |
| llvm::errs() << "-> " << Result << "\n"; |
| if (Result && Result->Details) { |
| llvm::errs() << " *Error Details* " << Result->Details << " \n"; |
| } |
| } |
| return Result; |
| } |
| ol_result_t olIterateDevicesWithCodeLoc(ol_device_iterate_cb_t Callback, |
| void *UserData, |
| ol_code_location_t *CodeLocation) { |
| currentCodeLocation() = CodeLocation; |
| ol_result_t Result = ::olIterateDevices(Callback, UserData); |
| |
| currentCodeLocation() = nullptr; |
| return Result; |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| llvm::Error olGetDeviceInfo_val(ol_device_handle_t Device, |
| ol_device_info_t PropName, size_t PropSize, |
| void *PropValue) { |
| if (offloadConfig().ValidationEnabled) { |
| if (PropSize == 0) { |
| return createOffloadError(error::ErrorCode::INVALID_SIZE, |
| "validation failure: PropSize == 0"); |
| } |
| |
| if (NULL == Device) { |
| return createOffloadError(error::ErrorCode::INVALID_NULL_HANDLE, |
| "validation failure: NULL == Device"); |
| } |
| |
| if (NULL == PropValue) { |
| return createOffloadError(error::ErrorCode::INVALID_NULL_POINTER, |
| "validation failure: NULL == PropValue"); |
| } |
| } |
| |
| return llvm::offload::olGetDeviceInfo_impl(Device, PropName, PropSize, |
| PropValue); |
| } |
| OL_APIEXPORT ol_result_t OL_APICALL olGetDeviceInfo(ol_device_handle_t Device, |
| ol_device_info_t PropName, |
| size_t PropSize, |
| void *PropValue) { |
| if (offloadConfig().TracingEnabled) { |
| llvm::errs() << "---> olGetDeviceInfo"; |
| } |
| |
| ol_result_t Result = llvmErrorToOffloadError( |
| olGetDeviceInfo_val(Device, PropName, PropSize, PropValue)); |
| |
| if (offloadConfig().TracingEnabled) { |
| ol_get_device_info_params_t Params = {&Device, &PropName, &PropSize, |
| &PropValue}; |
| llvm::errs() << "(" << &Params << ")"; |
| llvm::errs() << "-> " << Result << "\n"; |
| if (Result && Result->Details) { |
| llvm::errs() << " *Error Details* " << Result->Details << " \n"; |
| } |
| } |
| return Result; |
| } |
| ol_result_t olGetDeviceInfoWithCodeLoc(ol_device_handle_t Device, |
| ol_device_info_t PropName, |
| size_t PropSize, void *PropValue, |
| ol_code_location_t *CodeLocation) { |
| currentCodeLocation() = CodeLocation; |
| ol_result_t Result = ::olGetDeviceInfo(Device, PropName, PropSize, PropValue); |
| |
| currentCodeLocation() = nullptr; |
| return Result; |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| llvm::Error olGetDeviceInfoSize_val(ol_device_handle_t Device, |
| ol_device_info_t PropName, |
| size_t *PropSizeRet) { |
| if (offloadConfig().ValidationEnabled) { |
| if (NULL == Device) { |
| return createOffloadError(error::ErrorCode::INVALID_NULL_HANDLE, |
| "validation failure: NULL == Device"); |
| } |
| |
| if (NULL == PropSizeRet) { |
| return createOffloadError(error::ErrorCode::INVALID_NULL_POINTER, |
| "validation failure: NULL == PropSizeRet"); |
| } |
| } |
| |
| return llvm::offload::olGetDeviceInfoSize_impl(Device, PropName, PropSizeRet); |
| } |
| OL_APIEXPORT ol_result_t OL_APICALL olGetDeviceInfoSize( |
| ol_device_handle_t Device, ol_device_info_t PropName, size_t *PropSizeRet) { |
| if (offloadConfig().TracingEnabled) { |
| llvm::errs() << "---> olGetDeviceInfoSize"; |
| } |
| |
| ol_result_t Result = llvmErrorToOffloadError( |
| olGetDeviceInfoSize_val(Device, PropName, PropSizeRet)); |
| |
| if (offloadConfig().TracingEnabled) { |
| ol_get_device_info_size_params_t Params = {&Device, &PropName, |
| &PropSizeRet}; |
| llvm::errs() << "(" << &Params << ")"; |
| llvm::errs() << "-> " << Result << "\n"; |
| if (Result && Result->Details) { |
| llvm::errs() << " *Error Details* " << Result->Details << " \n"; |
| } |
| } |
| return Result; |
| } |
| ol_result_t olGetDeviceInfoSizeWithCodeLoc(ol_device_handle_t Device, |
| ol_device_info_t PropName, |
| size_t *PropSizeRet, |
| ol_code_location_t *CodeLocation) { |
| currentCodeLocation() = CodeLocation; |
| ol_result_t Result = ::olGetDeviceInfoSize(Device, PropName, PropSizeRet); |
| |
| currentCodeLocation() = nullptr; |
| return Result; |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| llvm::Error olMemAlloc_val(ol_device_handle_t Device, ol_alloc_type_t Type, |
| size_t Size, void **AllocationOut) { |
| if (offloadConfig().ValidationEnabled) { |
| if (Size == 0) { |
| return createOffloadError(error::ErrorCode::INVALID_SIZE, |
| "validation failure: Size == 0"); |
| } |
| |
| if (NULL == Device) { |
| return createOffloadError(error::ErrorCode::INVALID_NULL_HANDLE, |
| "validation failure: NULL == Device"); |
| } |
| |
| if (NULL == AllocationOut) { |
| return createOffloadError(error::ErrorCode::INVALID_NULL_POINTER, |
| "validation failure: NULL == AllocationOut"); |
| } |
| } |
| |
| return llvm::offload::olMemAlloc_impl(Device, Type, Size, AllocationOut); |
| } |
| OL_APIEXPORT ol_result_t OL_APICALL olMemAlloc(ol_device_handle_t Device, |
| ol_alloc_type_t Type, |
| size_t Size, |
| void **AllocationOut) { |
| if (offloadConfig().TracingEnabled) { |
| llvm::errs() << "---> olMemAlloc"; |
| } |
| |
| ol_result_t Result = llvmErrorToOffloadError( |
| olMemAlloc_val(Device, Type, Size, AllocationOut)); |
| |
| if (offloadConfig().TracingEnabled) { |
| ol_mem_alloc_params_t Params = {&Device, &Type, &Size, &AllocationOut}; |
| llvm::errs() << "(" << &Params << ")"; |
| llvm::errs() << "-> " << Result << "\n"; |
| if (Result && Result->Details) { |
| llvm::errs() << " *Error Details* " << Result->Details << " \n"; |
| } |
| } |
| return Result; |
| } |
| ol_result_t olMemAllocWithCodeLoc(ol_device_handle_t Device, |
| ol_alloc_type_t Type, size_t Size, |
| void **AllocationOut, |
| ol_code_location_t *CodeLocation) { |
| currentCodeLocation() = CodeLocation; |
| ol_result_t Result = ::olMemAlloc(Device, Type, Size, AllocationOut); |
| |
| currentCodeLocation() = nullptr; |
| return Result; |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| llvm::Error olMemFree_val(void *Address) { |
| if (offloadConfig().ValidationEnabled) { |
| if (NULL == Address) { |
| return createOffloadError(error::ErrorCode::INVALID_NULL_POINTER, |
| "validation failure: NULL == Address"); |
| } |
| } |
| |
| return llvm::offload::olMemFree_impl(Address); |
| } |
| OL_APIEXPORT ol_result_t OL_APICALL olMemFree(void *Address) { |
| if (offloadConfig().TracingEnabled) { |
| llvm::errs() << "---> olMemFree"; |
| } |
| |
| ol_result_t Result = llvmErrorToOffloadError(olMemFree_val(Address)); |
| |
| if (offloadConfig().TracingEnabled) { |
| ol_mem_free_params_t Params = {&Address}; |
| llvm::errs() << "(" << &Params << ")"; |
| llvm::errs() << "-> " << Result << "\n"; |
| if (Result && Result->Details) { |
| llvm::errs() << " *Error Details* " << Result->Details << " \n"; |
| } |
| } |
| return Result; |
| } |
| ol_result_t olMemFreeWithCodeLoc(void *Address, |
| ol_code_location_t *CodeLocation) { |
| currentCodeLocation() = CodeLocation; |
| ol_result_t Result = ::olMemFree(Address); |
| |
| currentCodeLocation() = nullptr; |
| return Result; |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| llvm::Error olMemcpy_val(ol_queue_handle_t Queue, void *DstPtr, |
| ol_device_handle_t DstDevice, void *SrcPtr, |
| ol_device_handle_t SrcDevice, size_t Size, |
| ol_event_handle_t *EventOut) { |
| if (offloadConfig().ValidationEnabled) { |
| if (Queue == NULL && EventOut != NULL) { |
| return createOffloadError( |
| error::ErrorCode::INVALID_ARGUMENT, |
| "validation failure: Queue == NULL && EventOut != NULL"); |
| } |
| |
| if (NULL == DstDevice) { |
| return createOffloadError(error::ErrorCode::INVALID_NULL_HANDLE, |
| "validation failure: NULL == DstDevice"); |
| } |
| |
| if (NULL == SrcDevice) { |
| return createOffloadError(error::ErrorCode::INVALID_NULL_HANDLE, |
| "validation failure: NULL == SrcDevice"); |
| } |
| |
| if (NULL == DstPtr) { |
| return createOffloadError(error::ErrorCode::INVALID_NULL_POINTER, |
| "validation failure: NULL == DstPtr"); |
| } |
| |
| if (NULL == SrcPtr) { |
| return createOffloadError(error::ErrorCode::INVALID_NULL_POINTER, |
| "validation failure: NULL == SrcPtr"); |
| } |
| } |
| |
| return llvm::offload::olMemcpy_impl(Queue, DstPtr, DstDevice, SrcPtr, |
| SrcDevice, Size, EventOut); |
| } |
| OL_APIEXPORT ol_result_t OL_APICALL |
| olMemcpy(ol_queue_handle_t Queue, void *DstPtr, ol_device_handle_t DstDevice, |
| void *SrcPtr, ol_device_handle_t SrcDevice, size_t Size, |
| ol_event_handle_t *EventOut) { |
| if (offloadConfig().TracingEnabled) { |
| llvm::errs() << "---> olMemcpy"; |
| } |
| |
| ol_result_t Result = llvmErrorToOffloadError(olMemcpy_val( |
| Queue, DstPtr, DstDevice, SrcPtr, SrcDevice, Size, EventOut)); |
| |
| if (offloadConfig().TracingEnabled) { |
| ol_memcpy_params_t Params = {&Queue, &DstPtr, &DstDevice, &SrcPtr, |
| &SrcDevice, &Size, &EventOut}; |
| llvm::errs() << "(" << &Params << ")"; |
| llvm::errs() << "-> " << Result << "\n"; |
| if (Result && Result->Details) { |
| llvm::errs() << " *Error Details* " << Result->Details << " \n"; |
| } |
| } |
| return Result; |
| } |
| ol_result_t olMemcpyWithCodeLoc(ol_queue_handle_t Queue, void *DstPtr, |
| ol_device_handle_t DstDevice, void *SrcPtr, |
| ol_device_handle_t SrcDevice, size_t Size, |
| ol_event_handle_t *EventOut, |
| ol_code_location_t *CodeLocation) { |
| currentCodeLocation() = CodeLocation; |
| ol_result_t Result = |
| ::olMemcpy(Queue, DstPtr, DstDevice, SrcPtr, SrcDevice, Size, EventOut); |
| |
| currentCodeLocation() = nullptr; |
| return Result; |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| llvm::Error olCreateQueue_val(ol_device_handle_t Device, |
| ol_queue_handle_t *Queue) { |
| if (offloadConfig().ValidationEnabled) { |
| if (NULL == Device) { |
| return createOffloadError(error::ErrorCode::INVALID_NULL_HANDLE, |
| "validation failure: NULL == Device"); |
| } |
| |
| if (NULL == Queue) { |
| return createOffloadError(error::ErrorCode::INVALID_NULL_POINTER, |
| "validation failure: NULL == Queue"); |
| } |
| } |
| |
| return llvm::offload::olCreateQueue_impl(Device, Queue); |
| } |
| OL_APIEXPORT ol_result_t OL_APICALL olCreateQueue(ol_device_handle_t Device, |
| ol_queue_handle_t *Queue) { |
| if (offloadConfig().TracingEnabled) { |
| llvm::errs() << "---> olCreateQueue"; |
| } |
| |
| ol_result_t Result = |
| llvmErrorToOffloadError(olCreateQueue_val(Device, Queue)); |
| |
| if (offloadConfig().TracingEnabled) { |
| ol_create_queue_params_t Params = {&Device, &Queue}; |
| llvm::errs() << "(" << &Params << ")"; |
| llvm::errs() << "-> " << Result << "\n"; |
| if (Result && Result->Details) { |
| llvm::errs() << " *Error Details* " << Result->Details << " \n"; |
| } |
| } |
| return Result; |
| } |
| ol_result_t olCreateQueueWithCodeLoc(ol_device_handle_t Device, |
| ol_queue_handle_t *Queue, |
| ol_code_location_t *CodeLocation) { |
| currentCodeLocation() = CodeLocation; |
| ol_result_t Result = ::olCreateQueue(Device, Queue); |
| |
| currentCodeLocation() = nullptr; |
| return Result; |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| llvm::Error olDestroyQueue_val(ol_queue_handle_t Queue) { |
| if (offloadConfig().ValidationEnabled) { |
| if (NULL == Queue) { |
| return createOffloadError(error::ErrorCode::INVALID_NULL_HANDLE, |
| "validation failure: NULL == Queue"); |
| } |
| } |
| |
| return llvm::offload::olDestroyQueue_impl(Queue); |
| } |
| OL_APIEXPORT ol_result_t OL_APICALL olDestroyQueue(ol_queue_handle_t Queue) { |
| if (offloadConfig().TracingEnabled) { |
| llvm::errs() << "---> olDestroyQueue"; |
| } |
| |
| ol_result_t Result = llvmErrorToOffloadError(olDestroyQueue_val(Queue)); |
| |
| if (offloadConfig().TracingEnabled) { |
| ol_destroy_queue_params_t Params = {&Queue}; |
| llvm::errs() << "(" << &Params << ")"; |
| llvm::errs() << "-> " << Result << "\n"; |
| if (Result && Result->Details) { |
| llvm::errs() << " *Error Details* " << Result->Details << " \n"; |
| } |
| } |
| return Result; |
| } |
| ol_result_t olDestroyQueueWithCodeLoc(ol_queue_handle_t Queue, |
| ol_code_location_t *CodeLocation) { |
| currentCodeLocation() = CodeLocation; |
| ol_result_t Result = ::olDestroyQueue(Queue); |
| |
| currentCodeLocation() = nullptr; |
| return Result; |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| llvm::Error olWaitQueue_val(ol_queue_handle_t Queue) { |
| if (offloadConfig().ValidationEnabled) { |
| if (NULL == Queue) { |
| return createOffloadError(error::ErrorCode::INVALID_NULL_HANDLE, |
| "validation failure: NULL == Queue"); |
| } |
| } |
| |
| return llvm::offload::olWaitQueue_impl(Queue); |
| } |
| OL_APIEXPORT ol_result_t OL_APICALL olWaitQueue(ol_queue_handle_t Queue) { |
| if (offloadConfig().TracingEnabled) { |
| llvm::errs() << "---> olWaitQueue"; |
| } |
| |
| ol_result_t Result = llvmErrorToOffloadError(olWaitQueue_val(Queue)); |
| |
| if (offloadConfig().TracingEnabled) { |
| ol_wait_queue_params_t Params = {&Queue}; |
| llvm::errs() << "(" << &Params << ")"; |
| llvm::errs() << "-> " << Result << "\n"; |
| if (Result && Result->Details) { |
| llvm::errs() << " *Error Details* " << Result->Details << " \n"; |
| } |
| } |
| return Result; |
| } |
| ol_result_t olWaitQueueWithCodeLoc(ol_queue_handle_t Queue, |
| ol_code_location_t *CodeLocation) { |
| currentCodeLocation() = CodeLocation; |
| ol_result_t Result = ::olWaitQueue(Queue); |
| |
| currentCodeLocation() = nullptr; |
| return Result; |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| llvm::Error olDestroyEvent_val(ol_event_handle_t Event) { |
| if (offloadConfig().ValidationEnabled) { |
| if (NULL == Event) { |
| return createOffloadError(error::ErrorCode::INVALID_NULL_HANDLE, |
| "validation failure: NULL == Event"); |
| } |
| } |
| |
| return llvm::offload::olDestroyEvent_impl(Event); |
| } |
| OL_APIEXPORT ol_result_t OL_APICALL olDestroyEvent(ol_event_handle_t Event) { |
| if (offloadConfig().TracingEnabled) { |
| llvm::errs() << "---> olDestroyEvent"; |
| } |
| |
| ol_result_t Result = llvmErrorToOffloadError(olDestroyEvent_val(Event)); |
| |
| if (offloadConfig().TracingEnabled) { |
| ol_destroy_event_params_t Params = {&Event}; |
| llvm::errs() << "(" << &Params << ")"; |
| llvm::errs() << "-> " << Result << "\n"; |
| if (Result && Result->Details) { |
| llvm::errs() << " *Error Details* " << Result->Details << " \n"; |
| } |
| } |
| return Result; |
| } |
| ol_result_t olDestroyEventWithCodeLoc(ol_event_handle_t Event, |
| ol_code_location_t *CodeLocation) { |
| currentCodeLocation() = CodeLocation; |
| ol_result_t Result = ::olDestroyEvent(Event); |
| |
| currentCodeLocation() = nullptr; |
| return Result; |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| llvm::Error olWaitEvent_val(ol_event_handle_t Event) { |
| if (offloadConfig().ValidationEnabled) { |
| if (NULL == Event) { |
| return createOffloadError(error::ErrorCode::INVALID_NULL_HANDLE, |
| "validation failure: NULL == Event"); |
| } |
| } |
| |
| return llvm::offload::olWaitEvent_impl(Event); |
| } |
| OL_APIEXPORT ol_result_t OL_APICALL olWaitEvent(ol_event_handle_t Event) { |
| if (offloadConfig().TracingEnabled) { |
| llvm::errs() << "---> olWaitEvent"; |
| } |
| |
| ol_result_t Result = llvmErrorToOffloadError(olWaitEvent_val(Event)); |
| |
| if (offloadConfig().TracingEnabled) { |
| ol_wait_event_params_t Params = {&Event}; |
| llvm::errs() << "(" << &Params << ")"; |
| llvm::errs() << "-> " << Result << "\n"; |
| if (Result && Result->Details) { |
| llvm::errs() << " *Error Details* " << Result->Details << " \n"; |
| } |
| } |
| return Result; |
| } |
| ol_result_t olWaitEventWithCodeLoc(ol_event_handle_t Event, |
| ol_code_location_t *CodeLocation) { |
| currentCodeLocation() = CodeLocation; |
| ol_result_t Result = ::olWaitEvent(Event); |
| |
| currentCodeLocation() = nullptr; |
| return Result; |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| llvm::Error olCreateProgram_val(ol_device_handle_t Device, const void *ProgData, |
| size_t ProgDataSize, |
| ol_program_handle_t *Program) { |
| if (offloadConfig().ValidationEnabled) { |
| if (NULL == Device) { |
| return createOffloadError(error::ErrorCode::INVALID_NULL_HANDLE, |
| "validation failure: NULL == Device"); |
| } |
| |
| if (NULL == ProgData) { |
| return createOffloadError(error::ErrorCode::INVALID_NULL_POINTER, |
| "validation failure: NULL == ProgData"); |
| } |
| |
| if (NULL == Program) { |
| return createOffloadError(error::ErrorCode::INVALID_NULL_POINTER, |
| "validation failure: NULL == Program"); |
| } |
| } |
| |
| return llvm::offload::olCreateProgram_impl(Device, ProgData, ProgDataSize, |
| Program); |
| } |
| OL_APIEXPORT ol_result_t OL_APICALL |
| olCreateProgram(ol_device_handle_t Device, const void *ProgData, |
| size_t ProgDataSize, ol_program_handle_t *Program) { |
| if (offloadConfig().TracingEnabled) { |
| llvm::errs() << "---> olCreateProgram"; |
| } |
| |
| ol_result_t Result = llvmErrorToOffloadError( |
| olCreateProgram_val(Device, ProgData, ProgDataSize, Program)); |
| |
| if (offloadConfig().TracingEnabled) { |
| ol_create_program_params_t Params = {&Device, &ProgData, &ProgDataSize, |
| &Program}; |
| llvm::errs() << "(" << &Params << ")"; |
| llvm::errs() << "-> " << Result << "\n"; |
| if (Result && Result->Details) { |
| llvm::errs() << " *Error Details* " << Result->Details << " \n"; |
| } |
| } |
| return Result; |
| } |
| ol_result_t olCreateProgramWithCodeLoc(ol_device_handle_t Device, |
| const void *ProgData, |
| size_t ProgDataSize, |
| ol_program_handle_t *Program, |
| ol_code_location_t *CodeLocation) { |
| currentCodeLocation() = CodeLocation; |
| ol_result_t Result = |
| ::olCreateProgram(Device, ProgData, ProgDataSize, Program); |
| |
| currentCodeLocation() = nullptr; |
| return Result; |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| llvm::Error olDestroyProgram_val(ol_program_handle_t Program) { |
| if (offloadConfig().ValidationEnabled) { |
| if (NULL == Program) { |
| return createOffloadError(error::ErrorCode::INVALID_NULL_HANDLE, |
| "validation failure: NULL == Program"); |
| } |
| } |
| |
| return llvm::offload::olDestroyProgram_impl(Program); |
| } |
| OL_APIEXPORT ol_result_t OL_APICALL |
| olDestroyProgram(ol_program_handle_t Program) { |
| if (offloadConfig().TracingEnabled) { |
| llvm::errs() << "---> olDestroyProgram"; |
| } |
| |
| ol_result_t Result = llvmErrorToOffloadError(olDestroyProgram_val(Program)); |
| |
| if (offloadConfig().TracingEnabled) { |
| ol_destroy_program_params_t Params = {&Program}; |
| llvm::errs() << "(" << &Params << ")"; |
| llvm::errs() << "-> " << Result << "\n"; |
| if (Result && Result->Details) { |
| llvm::errs() << " *Error Details* " << Result->Details << " \n"; |
| } |
| } |
| return Result; |
| } |
| ol_result_t olDestroyProgramWithCodeLoc(ol_program_handle_t Program, |
| ol_code_location_t *CodeLocation) { |
| currentCodeLocation() = CodeLocation; |
| ol_result_t Result = ::olDestroyProgram(Program); |
| |
| currentCodeLocation() = nullptr; |
| return Result; |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| llvm::Error olGetKernel_val(ol_program_handle_t Program, const char *KernelName, |
| ol_kernel_handle_t *Kernel) { |
| if (offloadConfig().ValidationEnabled) { |
| if (NULL == Program) { |
| return createOffloadError(error::ErrorCode::INVALID_NULL_HANDLE, |
| "validation failure: NULL == Program"); |
| } |
| |
| if (NULL == KernelName) { |
| return createOffloadError(error::ErrorCode::INVALID_NULL_POINTER, |
| "validation failure: NULL == KernelName"); |
| } |
| |
| if (NULL == Kernel) { |
| return createOffloadError(error::ErrorCode::INVALID_NULL_POINTER, |
| "validation failure: NULL == Kernel"); |
| } |
| } |
| |
| return llvm::offload::olGetKernel_impl(Program, KernelName, Kernel); |
| } |
| OL_APIEXPORT ol_result_t OL_APICALL olGetKernel(ol_program_handle_t Program, |
| const char *KernelName, |
| ol_kernel_handle_t *Kernel) { |
| if (offloadConfig().TracingEnabled) { |
| llvm::errs() << "---> olGetKernel"; |
| } |
| |
| ol_result_t Result = |
| llvmErrorToOffloadError(olGetKernel_val(Program, KernelName, Kernel)); |
| |
| if (offloadConfig().TracingEnabled) { |
| ol_get_kernel_params_t Params = {&Program, &KernelName, &Kernel}; |
| llvm::errs() << "(" << &Params << ")"; |
| llvm::errs() << "-> " << Result << "\n"; |
| if (Result && Result->Details) { |
| llvm::errs() << " *Error Details* " << Result->Details << " \n"; |
| } |
| } |
| return Result; |
| } |
| ol_result_t olGetKernelWithCodeLoc(ol_program_handle_t Program, |
| const char *KernelName, |
| ol_kernel_handle_t *Kernel, |
| ol_code_location_t *CodeLocation) { |
| currentCodeLocation() = CodeLocation; |
| ol_result_t Result = ::olGetKernel(Program, KernelName, Kernel); |
| |
| currentCodeLocation() = nullptr; |
| return Result; |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| llvm::Error |
| olLaunchKernel_val(ol_queue_handle_t Queue, ol_device_handle_t Device, |
| ol_kernel_handle_t Kernel, const void *ArgumentsData, |
| size_t ArgumentsSize, |
| const ol_kernel_launch_size_args_t *LaunchSizeArgs, |
| ol_event_handle_t *EventOut) { |
| if (offloadConfig().ValidationEnabled) { |
| if (Queue == NULL && EventOut != NULL) { |
| return createOffloadError( |
| error::ErrorCode::INVALID_ARGUMENT, |
| "validation failure: Queue == NULL && EventOut != NULL"); |
| } |
| |
| if (NULL == Device) { |
| return createOffloadError(error::ErrorCode::INVALID_NULL_HANDLE, |
| "validation failure: NULL == Device"); |
| } |
| |
| if (NULL == Kernel) { |
| return createOffloadError(error::ErrorCode::INVALID_NULL_HANDLE, |
| "validation failure: NULL == Kernel"); |
| } |
| |
| if (NULL == ArgumentsData) { |
| return createOffloadError(error::ErrorCode::INVALID_NULL_POINTER, |
| "validation failure: NULL == ArgumentsData"); |
| } |
| |
| if (NULL == LaunchSizeArgs) { |
| return createOffloadError(error::ErrorCode::INVALID_NULL_POINTER, |
| "validation failure: NULL == LaunchSizeArgs"); |
| } |
| } |
| |
| return llvm::offload::olLaunchKernel_impl(Queue, Device, Kernel, |
| ArgumentsData, ArgumentsSize, |
| LaunchSizeArgs, EventOut); |
| } |
| OL_APIEXPORT ol_result_t OL_APICALL olLaunchKernel( |
| ol_queue_handle_t Queue, ol_device_handle_t Device, |
| ol_kernel_handle_t Kernel, const void *ArgumentsData, size_t ArgumentsSize, |
| const ol_kernel_launch_size_args_t *LaunchSizeArgs, |
| ol_event_handle_t *EventOut) { |
| if (offloadConfig().TracingEnabled) { |
| llvm::errs() << "---> olLaunchKernel"; |
| } |
| |
| ol_result_t Result = llvmErrorToOffloadError( |
| olLaunchKernel_val(Queue, Device, Kernel, ArgumentsData, ArgumentsSize, |
| LaunchSizeArgs, EventOut)); |
| |
| if (offloadConfig().TracingEnabled) { |
| ol_launch_kernel_params_t Params = { |
| &Queue, &Device, &Kernel, &ArgumentsData, |
| &ArgumentsSize, &LaunchSizeArgs, &EventOut}; |
| llvm::errs() << "(" << &Params << ")"; |
| llvm::errs() << "-> " << Result << "\n"; |
| if (Result && Result->Details) { |
| llvm::errs() << " *Error Details* " << Result->Details << " \n"; |
| } |
| } |
| return Result; |
| } |
| ol_result_t olLaunchKernelWithCodeLoc( |
| ol_queue_handle_t Queue, ol_device_handle_t Device, |
| ol_kernel_handle_t Kernel, const void *ArgumentsData, size_t ArgumentsSize, |
| const ol_kernel_launch_size_args_t *LaunchSizeArgs, |
| ol_event_handle_t *EventOut, ol_code_location_t *CodeLocation) { |
| currentCodeLocation() = CodeLocation; |
| ol_result_t Result = |
| ::olLaunchKernel(Queue, Device, Kernel, ArgumentsData, ArgumentsSize, |
| LaunchSizeArgs, EventOut); |
| |
| currentCodeLocation() = nullptr; |
| return Result; |
| } |
