From 7a2516568d59b113bdcecd801a0fc571b5fb3eec Mon Sep 17 00:00:00 2001 From: Jason Ekstrand Date: Fri, 24 Sep 2021 15:19:16 -0500 Subject: [PATCH] radv: Switch to the new common vk_error helpers Also, change every vk_error to use the closest object instead of fetching all the way back to the instance. Reviewed-by: Samuel Pitoiset Part-of: --- docs/envvars.rst | 2 - src/amd/vulkan/radv_acceleration_structure.c | 8 +- src/amd/vulkan/radv_android.c | 14 ++-- src/amd/vulkan/radv_cmd_buffer.c | 8 +- src/amd/vulkan/radv_debug.h | 35 +++++---- src/amd/vulkan/radv_descriptor_set.c | 20 ++--- src/amd/vulkan/radv_device.c | 78 ++++++++++---------- src/amd/vulkan/radv_formats.c | 2 +- src/amd/vulkan/radv_image.c | 8 +- src/amd/vulkan/radv_pass.c | 4 +- src/amd/vulkan/radv_pipeline.c | 4 +- src/amd/vulkan/radv_pipeline_cache.c | 4 +- src/amd/vulkan/radv_pipeline_rt.c | 2 +- src/amd/vulkan/radv_private.h | 16 +--- src/amd/vulkan/radv_query.c | 6 +- src/amd/vulkan/radv_shader.c | 2 +- src/amd/vulkan/radv_util.c | 45 ----------- 17 files changed, 97 insertions(+), 161 deletions(-) diff --git a/docs/envvars.rst b/docs/envvars.rst index 3669f907b04..be9096505ed 100644 --- a/docs/envvars.rst +++ b/docs/envvars.rst @@ -618,8 +618,6 @@ RADV driver environment variables force all allocated buffers to be referenced in submissions ``checkir`` validate the LLVM IR before LLVM compiles the shader - ``errors`` - display more info about errors ``forcecompress`` Enables DCC,FMASK,CMASK,HTILE in situations where the driver supports it but normally does not deem it beneficial. diff --git a/src/amd/vulkan/radv_acceleration_structure.c b/src/amd/vulkan/radv_acceleration_structure.c index 04424f60566..d4382886383 100644 --- a/src/amd/vulkan/radv_acceleration_structure.c +++ b/src/amd/vulkan/radv_acceleration_structure.c @@ -97,7 +97,7 @@ radv_CreateAccelerationStructureKHR(VkDevice _device, accel = vk_alloc2(&device->vk.alloc, pAllocator, sizeof(*accel), 8, VK_SYSTEM_ALLOCATION_SCOPE_OBJECT); if (accel == NULL) - return vk_error(device->instance, VK_ERROR_OUT_OF_HOST_MEMORY); + return vk_error(device, VK_ERROR_OUT_OF_HOST_MEMORY); vk_object_base_init(&device->vk, &accel->base, VK_OBJECT_TYPE_ACCELERATION_STRUCTURE_KHR); @@ -145,7 +145,7 @@ radv_WriteAccelerationStructuresPropertiesKHR( RADV_FROM_HANDLE(radv_acceleration_structure, accel, pAccelerationStructures[i]); const char *base_ptr = (const char *)device->ws->buffer_map(accel->bo); if (!base_ptr) - return vk_error(device->instance, VK_ERROR_OUT_OF_HOST_MEMORY); + return vk_error(device, VK_ERROR_OUT_OF_HOST_MEMORY); const struct radv_accel_struct_header *header = (const void*)(base_ptr + accel->mem_offset); if (stride * i + sizeof(VkDeviceSize) <= dataSize) { @@ -339,7 +339,7 @@ build_instances(struct radv_device *device, struct radv_bvh_build_ctx *ctx, (VkAccelerationStructureKHR)instance->accelerationStructureReference); const void *src_base = device->ws->buffer_map(src_accel_struct->bo); if (!src_base) - return vk_error(device->instance, VK_ERROR_OUT_OF_HOST_MEMORY); + return vk_error(device, VK_ERROR_OUT_OF_HOST_MEMORY); src_base = (const char *)src_base + src_accel_struct->mem_offset; const struct radv_accel_struct_header *src_header = src_base; @@ -532,7 +532,7 @@ build_bvh(struct radv_device *device, const VkAccelerationStructureBuildGeometry char *base_ptr = (char*)device->ws->buffer_map(accel->bo); if (!base_ptr) - return vk_error(device->instance, VK_ERROR_OUT_OF_HOST_MEMORY); + return vk_error(device, VK_ERROR_OUT_OF_HOST_MEMORY); base_ptr = base_ptr + accel->mem_offset; struct radv_accel_struct_header *header = (void*)base_ptr; diff --git a/src/amd/vulkan/radv_android.c b/src/amd/vulkan/radv_android.c index 3275923ac6f..f9aa3189df6 100644 --- a/src/amd/vulkan/radv_android.c +++ b/src/amd/vulkan/radv_android.c @@ -121,7 +121,7 @@ radv_image_from_gralloc(VkDevice device_h, const VkImageCreateInfo *base_info, VkResult result; if (gralloc_info->handle->numFds != 1) { - return vk_errorf(device->instance, VK_ERROR_INVALID_EXTERNAL_HANDLE, + return vk_errorf(device, VK_ERROR_INVALID_EXTERNAL_HANDLE, "VkNativeBufferANDROID::handle::numFds is %d, " "expected 1", gralloc_info->handle->numFds); @@ -255,7 +255,7 @@ radv_GetSwapchainGrallocUsageANDROID(VkDevice device_h, VkFormat format, result = radv_GetPhysicalDeviceImageFormatProperties2(phys_dev_h, &image_format_info, &image_format_props); if (result != VK_SUCCESS) { - return vk_errorf(device->instance, result, + return vk_errorf(device, result, "radv_GetPhysicalDeviceImageFormatProperties2 failed " "inside %s", __func__); @@ -272,7 +272,7 @@ radv_GetSwapchainGrallocUsageANDROID(VkDevice device_h, VkFormat format, * gralloc swapchains. */ if (imageUsage != 0) { - return vk_errorf(device->instance, VK_ERROR_FORMAT_NOT_SUPPORTED, + return vk_errorf(device, VK_ERROR_FORMAT_NOT_SUPPORTED, "unsupported VkImageUsageFlags(0x%x) for gralloc " "swapchain", imageUsage); @@ -313,7 +313,7 @@ radv_GetSwapchainGrallocUsage2ANDROID(VkDevice device_h, VkFormat format, *grallocProducerUsage = 0; if (swapchainImageUsage & VK_SWAPCHAIN_IMAGE_USAGE_SHARED_BIT_ANDROID) - return vk_errorf(device->instance, VK_ERROR_FORMAT_NOT_SUPPORTED, + return vk_errorf(device, VK_ERROR_FORMAT_NOT_SUPPORTED, "The Vulkan loader tried to query shared presentable image support"); const VkPhysicalDeviceImageFormatInfo2 image_format_info = { @@ -332,7 +332,7 @@ radv_GetSwapchainGrallocUsage2ANDROID(VkDevice device_h, VkFormat format, result = radv_GetPhysicalDeviceImageFormatProperties2(phys_dev_h, &image_format_info, &image_format_props); if (result != VK_SUCCESS) { - return vk_errorf(device->instance, result, + return vk_errorf(device, result, "radv_GetPhysicalDeviceImageFormatProperties2 failed " "inside %s", __func__); @@ -350,7 +350,7 @@ radv_GetSwapchainGrallocUsage2ANDROID(VkDevice device_h, VkFormat format, } if (imageUsage != 0) { - return vk_errorf(device->instance, VK_ERROR_FORMAT_NOT_SUPPORTED, + return vk_errorf(device, VK_ERROR_FORMAT_NOT_SUPPORTED, "unsupported VkImageUsageFlags(0x%x) for gralloc " "swapchain", imageUsage); @@ -406,7 +406,7 @@ radv_AcquireImageANDROID(VkDevice device_h, VkImage image_h, int nativeFenceFd, VkResult err = (errno == EMFILE) ? VK_ERROR_TOO_MANY_OBJECTS : VK_ERROR_OUT_OF_HOST_MEMORY; close(nativeFenceFd); - return vk_error(device->instance, err); + return vk_error(device, err); } } else if (semaphore != VK_NULL_HANDLE) { semaphore_fd = nativeFenceFd; diff --git a/src/amd/vulkan/radv_cmd_buffer.c b/src/amd/vulkan/radv_cmd_buffer.c index 009f481d855..9e76af12365 100644 --- a/src/amd/vulkan/radv_cmd_buffer.c +++ b/src/amd/vulkan/radv_cmd_buffer.c @@ -424,7 +424,7 @@ radv_create_cmd_buffer(struct radv_device *device, struct radv_cmd_pool *pool, unsigned ring; cmd_buffer = vk_zalloc(&pool->alloc, sizeof(*cmd_buffer), 8, VK_SYSTEM_ALLOCATION_SCOPE_OBJECT); if (cmd_buffer == NULL) - return vk_error(device->instance, VK_ERROR_OUT_OF_HOST_MEMORY); + return vk_error(device, VK_ERROR_OUT_OF_HOST_MEMORY); VkResult result = vk_command_buffer_init(&cmd_buffer->vk, &device->vk); @@ -445,7 +445,7 @@ radv_create_cmd_buffer(struct radv_device *device, struct radv_cmd_pool *pool, cmd_buffer->cs = device->ws->cs_create(device->ws, ring); if (!cmd_buffer->cs) { radv_destroy_cmd_buffer(cmd_buffer); - return vk_error(device->instance, VK_ERROR_OUT_OF_HOST_MEMORY); + return vk_error(device, VK_ERROR_OUT_OF_HOST_MEMORY); } vk_object_base_init(&device->vk, &cmd_buffer->meta_push_descriptors.base, @@ -4311,7 +4311,7 @@ radv_EndCommandBuffer(VkCommandBuffer commandBuffer) VkResult result = cmd_buffer->device->ws->cs_finalize(cmd_buffer->cs); if (result != VK_SUCCESS) - return vk_error(cmd_buffer->device->instance, result); + return vk_error(cmd_buffer, result); cmd_buffer->status = RADV_CMD_BUFFER_STATUS_EXECUTABLE; @@ -5073,7 +5073,7 @@ radv_CreateCommandPool(VkDevice _device, const VkCommandPoolCreateInfo *pCreateI pool = vk_alloc2(&device->vk.alloc, pAllocator, sizeof(*pool), 8, VK_SYSTEM_ALLOCATION_SCOPE_OBJECT); if (pool == NULL) - return vk_error(device->instance, VK_ERROR_OUT_OF_HOST_MEMORY); + return vk_error(device, VK_ERROR_OUT_OF_HOST_MEMORY); vk_object_base_init(&device->vk, &pool->base, VK_OBJECT_TYPE_COMMAND_POOL); diff --git a/src/amd/vulkan/radv_debug.h b/src/amd/vulkan/radv_debug.h index 14b3a5160b1..19dc2275146 100644 --- a/src/amd/vulkan/radv_debug.h +++ b/src/amd/vulkan/radv_debug.h @@ -45,24 +45,23 @@ enum { RADV_DEBUG_NO_DYNAMIC_BOUNDS = 1ull << 14, RADV_DEBUG_NO_OUT_OF_ORDER = 1ull << 15, RADV_DEBUG_INFO = 1ull << 16, - RADV_DEBUG_ERRORS = 1ull << 17, - RADV_DEBUG_STARTUP = 1ull << 18, - RADV_DEBUG_CHECKIR = 1ull << 19, - RADV_DEBUG_NOBINNING = 1ull << 20, - RADV_DEBUG_NO_NGG = 1ull << 21, - RADV_DEBUG_DUMP_META_SHADERS = 1ull << 22, - RADV_DEBUG_NO_MEMORY_CACHE = 1ull << 23, - RADV_DEBUG_DISCARD_TO_DEMOTE = 1ull << 24, - RADV_DEBUG_LLVM = 1ull << 25, - RADV_DEBUG_FORCE_COMPRESS = 1ull << 26, - RADV_DEBUG_HANG = 1ull << 27, - RADV_DEBUG_IMG = 1ull << 28, - RADV_DEBUG_NO_UMR = 1ull << 29, - RADV_DEBUG_INVARIANT_GEOM = 1ull << 30, - RADV_DEBUG_NO_DISPLAY_DCC = 1ull << 31, - RADV_DEBUG_NO_TC_COMPAT_CMASK = 1ull << 32, - RADV_DEBUG_NO_VRS_FLAT_SHADING = 1ull << 33, - RADV_DEBUG_NO_ATOC_DITHERING = 1ull << 34, + RADV_DEBUG_STARTUP = 1ull << 17, + RADV_DEBUG_CHECKIR = 1ull << 18, + RADV_DEBUG_NOBINNING = 1ull << 19, + RADV_DEBUG_NO_NGG = 1ull << 20, + RADV_DEBUG_DUMP_META_SHADERS = 1ull << 21, + RADV_DEBUG_NO_MEMORY_CACHE = 1ull << 22, + RADV_DEBUG_DISCARD_TO_DEMOTE = 1ull << 23, + RADV_DEBUG_LLVM = 1ull << 24, + RADV_DEBUG_FORCE_COMPRESS = 1ull << 25, + RADV_DEBUG_HANG = 1ull << 26, + RADV_DEBUG_IMG = 1ull << 27, + RADV_DEBUG_NO_UMR = 1ull << 28, + RADV_DEBUG_INVARIANT_GEOM = 1ull << 29, + RADV_DEBUG_NO_DISPLAY_DCC = 1ull << 30, + RADV_DEBUG_NO_TC_COMPAT_CMASK = 1ull << 31, + RADV_DEBUG_NO_VRS_FLAT_SHADING = 1ull << 32, + RADV_DEBUG_NO_ATOC_DITHERING = 1ull << 33, }; enum { diff --git a/src/amd/vulkan/radv_descriptor_set.c b/src/amd/vulkan/radv_descriptor_set.c index 4508fe64230..1b1708c3c7f 100644 --- a/src/amd/vulkan/radv_descriptor_set.c +++ b/src/amd/vulkan/radv_descriptor_set.c @@ -136,7 +136,7 @@ radv_CreateDescriptorSetLayout(VkDevice _device, const VkDescriptorSetLayoutCrea set_layout = vk_zalloc2(&device->vk.alloc, pAllocator, size, 8, VK_SYSTEM_ALLOCATION_SCOPE_OBJECT); if (!set_layout) - return vk_error(device->instance, VK_ERROR_OUT_OF_HOST_MEMORY); + return vk_error(device, VK_ERROR_OUT_OF_HOST_MEMORY); vk_object_base_init(&device->vk, &set_layout->base, VK_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT); @@ -166,7 +166,7 @@ radv_CreateDescriptorSetLayout(VkDevice _device, const VkDescriptorSetLayoutCrea if (result != VK_SUCCESS) { vk_object_base_finish(&set_layout->base); vk_free2(&device->vk.alloc, pAllocator, set_layout); - return vk_error(device->instance, result); + return vk_error(device, result); } set_layout->binding_count = num_bindings; @@ -480,7 +480,7 @@ radv_CreatePipelineLayout(VkDevice _device, const VkPipelineLayoutCreateInfo *pC layout = vk_alloc2(&device->vk.alloc, pAllocator, sizeof(*layout), 8, VK_SYSTEM_ALLOCATION_SCOPE_OBJECT); if (layout == NULL) - return vk_error(device->instance, VK_ERROR_OUT_OF_HOST_MEMORY); + return vk_error(device, VK_ERROR_OUT_OF_HOST_MEMORY); vk_object_base_init(&device->vk, &layout->base, VK_OBJECT_TYPE_PIPELINE_LAYOUT); @@ -572,7 +572,7 @@ radv_descriptor_set_create(struct radv_device *device, struct radv_descriptor_po set = vk_alloc2(&device->vk.alloc, NULL, mem_size, 8, VK_SYSTEM_ALLOCATION_SCOPE_OBJECT); if (!set) - return vk_error(device->instance, VK_ERROR_OUT_OF_HOST_MEMORY); + return vk_error(device, VK_ERROR_OUT_OF_HOST_MEMORY); } memset(set, 0, mem_size); @@ -797,7 +797,7 @@ radv_CreateDescriptorPool(VkDevice _device, const VkDescriptorPoolCreateInfo *pC pool = vk_alloc2(&device->vk.alloc, pAllocator, size, 8, VK_SYSTEM_ALLOCATION_SCOPE_OBJECT); if (!pool) - return vk_error(device->instance, VK_ERROR_OUT_OF_HOST_MEMORY); + return vk_error(device, VK_ERROR_OUT_OF_HOST_MEMORY); memset(pool, 0, sizeof(*pool)); @@ -817,19 +817,19 @@ radv_CreateDescriptorPool(VkDevice _device, const VkDescriptorPoolCreateInfo *pC RADV_BO_PRIORITY_DESCRIPTOR, 0, &pool->bo); if (result != VK_SUCCESS) { radv_destroy_descriptor_pool(device, pAllocator, pool); - return vk_error(device->instance, result); + return vk_error(device, result); } pool->mapped_ptr = (uint8_t *)device->ws->buffer_map(pool->bo); if (!pool->mapped_ptr) { radv_destroy_descriptor_pool(device, pAllocator, pool); - return vk_error(device->instance, VK_ERROR_OUT_OF_DEVICE_MEMORY); + return vk_error(device, VK_ERROR_OUT_OF_DEVICE_MEMORY); } } else { pool->host_bo = vk_alloc2(&device->vk.alloc, pAllocator, bo_size, 8, VK_SYSTEM_ALLOCATION_SCOPE_OBJECT); if (!pool->host_bo) { radv_destroy_descriptor_pool(device, pAllocator, pool); - return vk_error(device->instance, VK_ERROR_OUT_OF_HOST_MEMORY); + return vk_error(device, VK_ERROR_OUT_OF_HOST_MEMORY); } pool->mapped_ptr = pool->host_bo; } @@ -1313,7 +1313,7 @@ radv_CreateDescriptorUpdateTemplate(VkDevice _device, templ = vk_alloc2(&device->vk.alloc, pAllocator, size, 8, VK_SYSTEM_ALLOCATION_SCOPE_OBJECT); if (!templ) - return vk_error(device->instance, VK_ERROR_OUT_OF_HOST_MEMORY); + return vk_error(device, VK_ERROR_OUT_OF_HOST_MEMORY); vk_object_base_init(&device->vk, &templ->base, VK_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE); @@ -1513,7 +1513,7 @@ radv_CreateSamplerYcbcrConversion(VkDevice _device, VK_SYSTEM_ALLOCATION_SCOPE_OBJECT); if (conversion == NULL) - return vk_error(device->instance, VK_ERROR_OUT_OF_HOST_MEMORY); + return vk_error(device, VK_ERROR_OUT_OF_HOST_MEMORY); vk_object_base_init(&device->vk, &conversion->base, VK_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION); diff --git a/src/amd/vulkan/radv_device.c b/src/amd/vulkan/radv_device.c index e0b4baa7061..a1ff738fa1f 100644 --- a/src/amd/vulkan/radv_device.c +++ b/src/amd/vulkan/radv_device.c @@ -824,7 +824,6 @@ static const struct debug_control radv_debug_options[] = { {"nodynamicbounds", RADV_DEBUG_NO_DYNAMIC_BOUNDS}, {"nooutoforder", RADV_DEBUG_NO_OUT_OF_ORDER}, {"info", RADV_DEBUG_INFO}, - {"errors", RADV_DEBUG_ERRORS}, {"startup", RADV_DEBUG_STARTUP}, {"checkir", RADV_DEBUG_CHECKIR}, {"nobinning", RADV_DEBUG_NOBINNING}, @@ -2548,7 +2547,7 @@ radv_queue_init(struct radv_device *device, struct radv_queue *queue, mtx_init(&queue->thread_mutex, mtx_plain); if (u_cnd_monotonic_init(&queue->thread_cond)) { vk_queue_finish(&queue->vk); - return vk_error(device->instance, VK_ERROR_INITIALIZATION_FAILED); + return vk_error(device, VK_ERROR_INITIALIZATION_FAILED); } queue->cond_created = true; @@ -2617,15 +2616,15 @@ radv_device_init_border_color(struct radv_device *device) RADV_BO_PRIORITY_SHADER, 0, &device->border_color_data.bo); if (result != VK_SUCCESS) - return vk_error(device->physical_device->instance, result); + return vk_error(device, result); result = device->ws->buffer_make_resident(device->ws, device->border_color_data.bo, true); if (result != VK_SUCCESS) - return vk_error(device->physical_device->instance, result); + return vk_error(device, result); device->border_color_data.colors_gpu_ptr = device->ws->buffer_map(device->border_color_data.bo); if (!device->border_color_data.colors_gpu_ptr) - return vk_error(device->physical_device->instance, VK_ERROR_OUT_OF_DEVICE_MEMORY); + return vk_error(device, VK_ERROR_OUT_OF_DEVICE_MEMORY); mtx_init(&device->border_color_data.mutex, mtx_plain); return VK_SUCCESS; @@ -2754,8 +2753,7 @@ _radv_device_set_lost(struct radv_device *device, const char *file, int line, co va_start(ap, msg); err = - __vk_errorv(device->physical_device->instance, device, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT, - VK_ERROR_DEVICE_LOST, file, line, msg, ap); + __vk_errorv(device, VK_ERROR_DEVICE_LOST, file, line, msg, ap); va_end(ap); return err; @@ -3966,7 +3964,7 @@ fail: if (gds_oa_bo && gds_oa_bo != queue->gds_oa_bo) queue->device->ws->buffer_destroy(queue->device->ws, gds_oa_bo); - return vk_error(queue->device->instance, result); + return vk_error(queue, result); } static VkResult @@ -4004,7 +4002,7 @@ radv_alloc_sem_counts(struct radv_device *device, struct radv_winsys_sem_counts (sizeof(*counts->syncobj) + sizeof(*counts->points)) * counts->timeline_syncobj_count); if (!counts->points) - return vk_error(device->instance, VK_ERROR_OUT_OF_HOST_MEMORY); + return vk_error(device, VK_ERROR_OUT_OF_HOST_MEMORY); counts->syncobj = (uint32_t *)(counts->points + counts->timeline_syncobj_count); } @@ -4699,7 +4697,7 @@ wait_for_submission_timelines_available(struct radv_deferred_queue_submission *s uint64_t *points = malloc((sizeof(uint64_t) + sizeof(uint32_t)) * syncobj_count); if (!points) - return vk_error(device->instance, VK_ERROR_OUT_OF_HOST_MEMORY); + return vk_error(device, VK_ERROR_OUT_OF_HOST_MEMORY); uint32_t *syncobj = (uint32_t *)(points + syncobj_count); @@ -4789,7 +4787,7 @@ radv_queue_trigger_submission(struct radv_deferred_queue_submission *submission, ret = thrd_create(&queue->submission_thread, radv_queue_submission_thread_run, queue); if (ret) { mtx_unlock(&queue->thread_mutex); - return vk_errorf(queue->device->instance, VK_ERROR_DEVICE_LOST, + return vk_errorf(queue, VK_ERROR_DEVICE_LOST, "Failed to start submission thread"); } queue->thread_running = true; @@ -5126,7 +5124,7 @@ radv_alloc_memory(struct radv_device *device, const VkMemoryAllocateInfo *pAlloc mem = vk_alloc2(&device->vk.alloc, pAllocator, sizeof(*mem), 8, VK_SYSTEM_ALLOCATION_SCOPE_OBJECT); if (mem == NULL) - return vk_error(device->instance, VK_ERROR_OUT_OF_HOST_MEMORY); + return vk_error(device, VK_ERROR_OUT_OF_HOST_MEMORY); radv_device_memory_init(mem, device, NULL); @@ -5329,7 +5327,7 @@ radv_MapMemory(VkDevice _device, VkDeviceMemory _memory, VkDeviceSize offset, Vk return VK_SUCCESS; } - return vk_error(device->instance, VK_ERROR_MEMORY_MAP_FAILED); + return vk_error(device, VK_ERROR_MEMORY_MAP_FAILED); } void @@ -5451,7 +5449,7 @@ radv_BindBufferMemory2(VkDevice _device, uint32_t bindInfoCount, radv_GetBufferMemoryRequirements2(_device, &info, &reqs); if (pBindInfos[i].memoryOffset + reqs.memoryRequirements.size > mem->alloc_size) { - return vk_errorf(device->instance, VK_ERROR_UNKNOWN, + return vk_errorf(device, VK_ERROR_UNKNOWN, "Device memory object too small for the buffer.\n"); } } @@ -5488,7 +5486,7 @@ radv_BindImageMemory2(VkDevice _device, uint32_t bindInfoCount, radv_GetImageMemoryRequirements2(_device, &info, &reqs); if (pBindInfos[i].memoryOffset + reqs.memoryRequirements.size > mem->alloc_size) { - return vk_errorf(device->instance, VK_ERROR_UNKNOWN, + return vk_errorf(device, VK_ERROR_UNKNOWN, "Device memory object too small for the image.\n"); } } @@ -5601,7 +5599,7 @@ radv_CreateFence(VkDevice _device, const VkFenceCreateInfo *pCreateInfo, fence = vk_zalloc2(&device->vk.alloc, pAllocator, sizeof(*fence), 8, VK_SYSTEM_ALLOCATION_SCOPE_OBJECT); if (!fence) - return vk_error(device->instance, VK_ERROR_OUT_OF_HOST_MEMORY); + return vk_error(device, VK_ERROR_OUT_OF_HOST_MEMORY); vk_object_base_init(&device->vk, &fence->base, VK_OBJECT_TYPE_FENCE); @@ -5613,7 +5611,7 @@ radv_CreateFence(VkDevice _device, const VkFenceCreateInfo *pCreateInfo, ret = device->ws->create_syncobj(device->ws, create_signaled, &fence->permanent.syncobj); if (ret) { radv_destroy_fence(device, pAllocator, fence); - return vk_error(device->instance, VK_ERROR_OUT_OF_HOST_MEMORY); + return vk_error(device, VK_ERROR_OUT_OF_HOST_MEMORY); } *pFence = radv_fence_to_handle(fence); @@ -5647,7 +5645,7 @@ radv_WaitForFences(VkDevice _device, uint32_t fenceCount, const VkFence *pFences handles = malloc(sizeof(uint32_t) * fenceCount); if (!handles) - return vk_error(device->instance, VK_ERROR_OUT_OF_HOST_MEMORY); + return vk_error(device, VK_ERROR_OUT_OF_HOST_MEMORY); for (uint32_t i = 0; i < fenceCount; ++i) { RADV_FROM_HANDLE(radv_fence, fence, pFences[i]); @@ -5917,7 +5915,7 @@ radv_CreateSemaphore(VkDevice _device, const VkSemaphoreCreateInfo *pCreateInfo, struct radv_semaphore *sem = vk_alloc2(&device->vk.alloc, pAllocator, sizeof(*sem), 8, VK_SYSTEM_ALLOCATION_SCOPE_OBJECT); if (!sem) - return vk_error(device->instance, VK_ERROR_OUT_OF_HOST_MEMORY); + return vk_error(device, VK_ERROR_OUT_OF_HOST_MEMORY); vk_object_base_init(&device->vk, &sem->base, VK_OBJECT_TYPE_SEMAPHORE); @@ -5929,7 +5927,7 @@ radv_CreateSemaphore(VkDevice _device, const VkSemaphoreCreateInfo *pCreateInfo, int ret = device->ws->create_syncobj(device->ws, false, &sem->permanent.syncobj); if (ret) { radv_destroy_semaphore(device, pAllocator, sem); - return vk_error(device->instance, VK_ERROR_OUT_OF_HOST_MEMORY); + return vk_error(device, VK_ERROR_OUT_OF_HOST_MEMORY); } device->ws->signal_syncobj(device->ws, sem->permanent.syncobj, initial_value); sem->permanent.timeline_syncobj.max_point = initial_value; @@ -5941,7 +5939,7 @@ radv_CreateSemaphore(VkDevice _device, const VkSemaphoreCreateInfo *pCreateInfo, int ret = device->ws->create_syncobj(device->ws, false, &sem->permanent.syncobj); if (ret) { radv_destroy_semaphore(device, pAllocator, sem); - return vk_error(device->instance, VK_ERROR_OUT_OF_HOST_MEMORY); + return vk_error(device, VK_ERROR_OUT_OF_HOST_MEMORY); } sem->permanent.kind = RADV_SEMAPHORE_SYNCOBJ; } @@ -6037,13 +6035,13 @@ radv_WaitSemaphores(VkDevice _device, const VkSemaphoreWaitInfo *pWaitInfo, uint return radv_wait_timelines(device, pWaitInfo, abs_timeout); if (pWaitInfo->semaphoreCount > UINT32_MAX / sizeof(uint32_t)) - return vk_errorf(device->instance, VK_ERROR_OUT_OF_HOST_MEMORY, + return vk_errorf(device, VK_ERROR_OUT_OF_HOST_MEMORY, "semaphoreCount integer overflow"); bool wait_all = !(pWaitInfo->flags & VK_SEMAPHORE_WAIT_ANY_BIT_KHR); uint32_t *handles = malloc(sizeof(*handles) * pWaitInfo->semaphoreCount); if (!handles) - return vk_error(device->instance, VK_ERROR_OUT_OF_HOST_MEMORY); + return vk_error(device, VK_ERROR_OUT_OF_HOST_MEMORY); for (uint32_t i = 0; i < pWaitInfo->semaphoreCount; ++i) { RADV_FROM_HANDLE(radv_semaphore, semaphore, pWaitInfo->pSemaphores[i]); @@ -6122,7 +6120,7 @@ radv_CreateEvent(VkDevice _device, const VkEventCreateInfo *pCreateInfo, VK_SYSTEM_ALLOCATION_SCOPE_OBJECT); if (!event) - return vk_error(device->instance, VK_ERROR_OUT_OF_HOST_MEMORY); + return vk_error(device, VK_ERROR_OUT_OF_HOST_MEMORY); vk_object_base_init(&device->vk, &event->base, VK_OBJECT_TYPE_EVENT); @@ -6132,13 +6130,13 @@ radv_CreateEvent(VkDevice _device, const VkEventCreateInfo *pCreateInfo, RADV_BO_PRIORITY_FENCE, 0, &event->bo); if (result != VK_SUCCESS) { radv_destroy_event(device, pAllocator, event); - return vk_error(device->instance, result); + return vk_error(device, result); } event->map = (uint64_t *)device->ws->buffer_map(event->bo); if (!event->map) { radv_destroy_event(device, pAllocator, event); - return vk_error(device->instance, VK_ERROR_OUT_OF_DEVICE_MEMORY); + return vk_error(device, VK_ERROR_OUT_OF_DEVICE_MEMORY); } *pEvent = radv_event_to_handle(event); @@ -6236,7 +6234,7 @@ radv_CreateBuffer(VkDevice _device, const VkBufferCreateInfo *pCreateInfo, buffer = vk_alloc2(&device->vk.alloc, pAllocator, sizeof(*buffer), 8, VK_SYSTEM_ALLOCATION_SCOPE_OBJECT); if (buffer == NULL) - return vk_error(device->instance, VK_ERROR_OUT_OF_HOST_MEMORY); + return vk_error(device, VK_ERROR_OUT_OF_HOST_MEMORY); radv_buffer_init(buffer, device, NULL, pCreateInfo->size, 0); @@ -6262,7 +6260,7 @@ radv_CreateBuffer(VkDevice _device, const VkBufferCreateInfo *pCreateInfo, replay_address, &buffer->bo); if (result != VK_SUCCESS) { radv_destroy_buffer(device, pAllocator, buffer); - return vk_error(device->instance, result); + return vk_error(device, result); } } @@ -6882,7 +6880,7 @@ radv_CreateFramebuffer(VkDevice _device, const VkFramebufferCreateInfo *pCreateI framebuffer = vk_alloc2(&device->vk.alloc, pAllocator, size, 8, VK_SYSTEM_ALLOCATION_SCOPE_OBJECT); if (framebuffer == NULL) - return vk_error(device->instance, VK_ERROR_OUT_OF_HOST_MEMORY); + return vk_error(device, VK_ERROR_OUT_OF_HOST_MEMORY); vk_object_base_init(&device->vk, &framebuffer->base, VK_OBJECT_TYPE_FRAMEBUFFER); @@ -7191,7 +7189,7 @@ radv_CreateSampler(VkDevice _device, const VkSamplerCreateInfo *pCreateInfo, sampler = vk_alloc2(&device->vk.alloc, pAllocator, sizeof(*sampler), 8, VK_SYSTEM_ALLOCATION_SCOPE_OBJECT); if (!sampler) - return vk_error(device->instance, VK_ERROR_OUT_OF_HOST_MEMORY); + return vk_error(device, VK_ERROR_OUT_OF_HOST_MEMORY); vk_object_base_init(&device->vk, &sampler->base, VK_OBJECT_TYPE_SAMPLER); @@ -7273,7 +7271,7 @@ radv_GetMemoryFdKHR(VkDevice _device, const VkMemoryGetFdInfoKHR *pGetFdInfo, in bool ret = radv_get_memory_fd(device, memory, pFD); if (ret == false) - return vk_error(device->instance, VK_ERROR_OUT_OF_DEVICE_MEMORY); + return vk_error(device, VK_ERROR_OUT_OF_DEVICE_MEMORY); return VK_SUCCESS; } @@ -7333,7 +7331,7 @@ radv_GetMemoryFdPropertiesKHR(VkDevice _device, VkExternalMemoryHandleTypeFlagBi enum radeon_bo_domain domains; enum radeon_bo_flag flags; if (!device->ws->buffer_get_flags_from_fd(device->ws, fd, &domains, &flags)) - return vk_error(device->instance, VK_ERROR_INVALID_EXTERNAL_HANDLE); + return vk_error(device, VK_ERROR_INVALID_EXTERNAL_HANDLE); pMemoryFdProperties->memoryTypeBits = radv_compute_valid_memory_types(device->physical_device, domains, flags); @@ -7347,7 +7345,7 @@ radv_GetMemoryFdPropertiesKHR(VkDevice _device, VkExternalMemoryHandleTypeFlagBi * * So opaque handle types fall into the default "unsupported" case. */ - return vk_error(device->instance, VK_ERROR_INVALID_EXTERNAL_HANDLE); + return vk_error(device, VK_ERROR_INVALID_EXTERNAL_HANDLE); } } @@ -7357,7 +7355,7 @@ radv_import_opaque_fd(struct radv_device *device, int fd, uint32_t *syncobj) uint32_t syncobj_handle = 0; int ret = device->ws->import_syncobj(device->ws, fd, &syncobj_handle); if (ret != 0) - return vk_error(device->instance, VK_ERROR_INVALID_EXTERNAL_HANDLE); + return vk_error(device, VK_ERROR_INVALID_EXTERNAL_HANDLE); if (*syncobj) device->ws->destroy_syncobj(device->ws, *syncobj); @@ -7379,7 +7377,7 @@ radv_import_sync_fd(struct radv_device *device, int fd, uint32_t *syncobj) int ret = device->ws->create_syncobj(device->ws, create_signaled, &syncobj_handle); if (ret) { - return vk_error(device->instance, VK_ERROR_OUT_OF_HOST_MEMORY); + return vk_error(device, VK_ERROR_OUT_OF_HOST_MEMORY); } } else { if (fd == -1) @@ -7389,7 +7387,7 @@ radv_import_sync_fd(struct radv_device *device, int fd, uint32_t *syncobj) if (fd != -1) { int ret = device->ws->import_syncobj_from_sync_file(device->ws, syncobj_handle, fd); if (ret) - return vk_error(device->instance, VK_ERROR_INVALID_EXTERNAL_HANDLE); + return vk_error(device, VK_ERROR_INVALID_EXTERNAL_HANDLE); close(fd); } @@ -7466,12 +7464,12 @@ radv_GetSemaphoreFdKHR(VkDevice _device, const VkSemaphoreGetFdInfoKHR *pGetFdIn case VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT: ret = device->ws->export_syncobj(device->ws, syncobj_handle, pFd); if (ret) - return vk_error(device->instance, VK_ERROR_TOO_MANY_OBJECTS); + return vk_error(device, VK_ERROR_TOO_MANY_OBJECTS); break; case VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT: ret = device->ws->export_syncobj_to_sync_file(device->ws, syncobj_handle, pFd); if (ret) - return vk_error(device->instance, VK_ERROR_TOO_MANY_OBJECTS); + return vk_error(device, VK_ERROR_TOO_MANY_OBJECTS); if (sem->temporary.kind != RADV_SEMAPHORE_NONE) { radv_destroy_semaphore_part(device, &sem->temporary); @@ -7585,12 +7583,12 @@ radv_GetFenceFdKHR(VkDevice _device, const VkFenceGetFdInfoKHR *pGetFdInfo, int case VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD_BIT: ret = device->ws->export_syncobj(device->ws, part->syncobj, pFd); if (ret) - return vk_error(device->instance, VK_ERROR_TOO_MANY_OBJECTS); + return vk_error(device, VK_ERROR_TOO_MANY_OBJECTS); break; case VK_EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD_BIT: ret = device->ws->export_syncobj_to_sync_file(device->ws, part->syncobj, pFd); if (ret) - return vk_error(device->instance, VK_ERROR_TOO_MANY_OBJECTS); + return vk_error(device, VK_ERROR_TOO_MANY_OBJECTS); if (part == &fence->temporary) { radv_destroy_fence_part(device, part); diff --git a/src/amd/vulkan/radv_formats.c b/src/amd/vulkan/radv_formats.c index 57b88abe49c..adfcc5265ef 100644 --- a/src/amd/vulkan/radv_formats.c +++ b/src/amd/vulkan/radv_formats.c @@ -1649,7 +1649,7 @@ radv_GetPhysicalDeviceImageFormatProperties2(VkPhysicalDevice physicalDevice, * vkGetPhysicalDeviceImageFormatProperties2 returns * VK_ERROR_FORMAT_NOT_SUPPORTED. */ - result = vk_errorf(physical_device->instance, VK_ERROR_FORMAT_NOT_SUPPORTED, + result = vk_errorf(physical_device, VK_ERROR_FORMAT_NOT_SUPPORTED, "unsupported VkExternalMemoryTypeFlagBitsKHR 0x%x", external_info->handleType); goto fail; diff --git a/src/amd/vulkan/radv_image.c b/src/amd/vulkan/radv_image.c index bd826c9b463..480ab404981 100644 --- a/src/amd/vulkan/radv_image.c +++ b/src/amd/vulkan/radv_image.c @@ -1686,7 +1686,7 @@ radv_image_create(VkDevice _device, const struct radv_image_create_info *create_ image = vk_zalloc2(&device->vk.alloc, alloc, image_struct_size, 8, VK_SYSTEM_ALLOCATION_SCOPE_OBJECT); if (!image) - return vk_error(device->instance, VK_ERROR_OUT_OF_HOST_MEMORY); + return vk_error(device, VK_ERROR_OUT_OF_HOST_MEMORY); vk_object_base_init(&device->vk, &image->base, VK_OBJECT_TYPE_IMAGE); @@ -1763,7 +1763,7 @@ radv_image_create(VkDevice _device, const struct radv_image_create_info *create_ RADEON_FLAG_VIRTUAL, RADV_BO_PRIORITY_VIRTUAL, 0, &image->bo); if (result != VK_SUCCESS) { radv_destroy_image(device, alloc, image); - return vk_error(device->instance, result); + return vk_error(device, result); } } @@ -2294,7 +2294,7 @@ radv_CreateImageView(VkDevice _device, const VkImageViewCreateInfo *pCreateInfo, view = vk_alloc2(&device->vk.alloc, pAllocator, sizeof(*view), 8, VK_SYSTEM_ALLOCATION_SCOPE_OBJECT); if (view == NULL) - return vk_error(device->instance, VK_ERROR_OUT_OF_HOST_MEMORY); + return vk_error(device, VK_ERROR_OUT_OF_HOST_MEMORY); radv_image_view_init(view, device, pCreateInfo, NULL); @@ -2349,7 +2349,7 @@ radv_CreateBufferView(VkDevice _device, const VkBufferViewCreateInfo *pCreateInf view = vk_alloc2(&device->vk.alloc, pAllocator, sizeof(*view), 8, VK_SYSTEM_ALLOCATION_SCOPE_OBJECT); if (!view) - return vk_error(device->instance, VK_ERROR_OUT_OF_HOST_MEMORY); + return vk_error(device, VK_ERROR_OUT_OF_HOST_MEMORY); radv_buffer_view_init(view, device, pCreateInfo); diff --git a/src/amd/vulkan/radv_pass.c b/src/amd/vulkan/radv_pass.c index d5121d62953..26063f57dd7 100644 --- a/src/amd/vulkan/radv_pass.c +++ b/src/amd/vulkan/radv_pass.c @@ -392,7 +392,7 @@ radv_CreateRenderPass2(VkDevice _device, const VkRenderPassCreateInfo2 *pCreateI pass = vk_alloc2(&device->vk.alloc, pAllocator, size, 8, VK_SYSTEM_ALLOCATION_SCOPE_OBJECT); if (pass == NULL) - return vk_error(device->instance, VK_ERROR_OUT_OF_HOST_MEMORY); + return vk_error(device, VK_ERROR_OUT_OF_HOST_MEMORY); memset(pass, 0, size); @@ -429,7 +429,7 @@ radv_CreateRenderPass2(VkDevice _device, const VkRenderPassCreateInfo2 *pCreateI VK_SYSTEM_ALLOCATION_SCOPE_OBJECT); if (pass->subpass_attachments == NULL) { radv_destroy_render_pass(device, pAllocator, pass); - return vk_error(device->instance, VK_ERROR_OUT_OF_HOST_MEMORY); + return vk_error(device, VK_ERROR_OUT_OF_HOST_MEMORY); } } else pass->subpass_attachments = NULL; diff --git a/src/amd/vulkan/radv_pipeline.c b/src/amd/vulkan/radv_pipeline.c index 0f49471059b..edc21068a9a 100644 --- a/src/amd/vulkan/radv_pipeline.c +++ b/src/amd/vulkan/radv_pipeline.c @@ -5607,7 +5607,7 @@ radv_graphics_pipeline_create(VkDevice _device, VkPipelineCache _cache, pipeline = vk_zalloc2(&device->vk.alloc, pAllocator, sizeof(*pipeline), 8, VK_SYSTEM_ALLOCATION_SCOPE_OBJECT); if (pipeline == NULL) - return vk_error(device->instance, VK_ERROR_OUT_OF_HOST_MEMORY); + return vk_error(device, VK_ERROR_OUT_OF_HOST_MEMORY); vk_object_base_init(&device->vk, &pipeline->base, VK_OBJECT_TYPE_PIPELINE); pipeline->type = RADV_PIPELINE_GRAPHICS; @@ -5757,7 +5757,7 @@ radv_compute_pipeline_create(VkDevice _device, VkPipelineCache _cache, VK_SYSTEM_ALLOCATION_SCOPE_OBJECT); if (pipeline == NULL) { free(rt_stack_sizes); - return vk_error(device->instance, VK_ERROR_OUT_OF_HOST_MEMORY); + return vk_error(device, VK_ERROR_OUT_OF_HOST_MEMORY); } vk_object_base_init(&device->vk, &pipeline->base, VK_OBJECT_TYPE_PIPELINE); diff --git a/src/amd/vulkan/radv_pipeline_cache.c b/src/amd/vulkan/radv_pipeline_cache.c index c31ab4819d6..7cbd4e10678 100644 --- a/src/amd/vulkan/radv_pipeline_cache.c +++ b/src/amd/vulkan/radv_pipeline_cache.c @@ -247,7 +247,7 @@ radv_pipeline_cache_grow(struct radv_pipeline_cache *cache) table = malloc(byte_size); if (table == NULL) - return vk_error(cache->device->instance, VK_ERROR_OUT_OF_HOST_MEMORY); + return vk_error(cache, VK_ERROR_OUT_OF_HOST_MEMORY); cache->hash_table = table; cache->table_size = table_size; @@ -549,7 +549,7 @@ radv_CreatePipelineCache(VkDevice _device, const VkPipelineCacheCreateInfo *pCre cache = vk_alloc2(&device->vk.alloc, pAllocator, sizeof(*cache), 8, VK_SYSTEM_ALLOCATION_SCOPE_OBJECT); if (cache == NULL) - return vk_error(device->instance, VK_ERROR_OUT_OF_HOST_MEMORY); + return vk_error(device, VK_ERROR_OUT_OF_HOST_MEMORY); if (pAllocator) cache->alloc = *pAllocator; diff --git a/src/amd/vulkan/radv_pipeline_rt.c b/src/amd/vulkan/radv_pipeline_rt.c index e7f558071b1..bb9daf5caf5 100644 --- a/src/amd/vulkan/radv_pipeline_rt.c +++ b/src/amd/vulkan/radv_pipeline_rt.c @@ -97,7 +97,7 @@ radv_rt_pipeline_library_create(VkDevice _device, VkPipelineCache _cache, pipeline = vk_zalloc2(&device->vk.alloc, pAllocator, sizeof(*pipeline), 8, VK_SYSTEM_ALLOCATION_SCOPE_OBJECT); if (pipeline == NULL) - return vk_error(device->instance, VK_ERROR_OUT_OF_HOST_MEMORY); + return vk_error(device, VK_ERROR_OUT_OF_HOST_MEMORY); vk_object_base_init(&device->vk, &pipeline->base, VK_OBJECT_TYPE_PIPELINE); pipeline->type = RADV_PIPELINE_LIBRARY; diff --git a/src/amd/vulkan/radv_private.h b/src/amd/vulkan/radv_private.h index 298784ce02c..678d9d553dd 100644 --- a/src/amd/vulkan/radv_private.h +++ b/src/amd/vulkan/radv_private.h @@ -59,6 +59,7 @@ #include "vk_device.h" #include "vk_format.h" #include "vk_instance.h" +#include "vk_log.h" #include "vk_physical_device.h" #include "vk_shader_module.h" #include "vk_command_buffer.h" @@ -208,21 +209,6 @@ radv_clear_mask(uint32_t *inout_mask, uint32_t clear_mask) struct radv_image_view; struct radv_instance; -VkResult __vk_errorv(struct radv_instance *instance, const void *object, - VkDebugReportObjectTypeEXT type, VkResult error, const char *file, int line, - const char *format, va_list args); - -VkResult __vk_errorf(struct radv_instance *instance, const void *object, - VkDebugReportObjectTypeEXT type, VkResult error, const char *file, int line, - const char *format, ...) radv_printflike(7, 8); - -#define vk_error(instance, error) \ - __vk_errorf(instance, NULL, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, error, __FILE__, __LINE__, \ - NULL); -#define vk_errorf(instance, error, format, ...) \ - __vk_errorf(instance, NULL, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, error, __FILE__, __LINE__, \ - format, ##__VA_ARGS__); - void radv_loge(const char *format, ...) radv_printflike(1, 2); void radv_loge_v(const char *format, va_list va); void radv_logi(const char *format, ...) radv_printflike(1, 2); diff --git a/src/amd/vulkan/radv_query.c b/src/amd/vulkan/radv_query.c index a34713900c6..af1d4a4a1e2 100644 --- a/src/amd/vulkan/radv_query.c +++ b/src/amd/vulkan/radv_query.c @@ -952,7 +952,7 @@ radv_CreateQueryPool(VkDevice _device, const VkQueryPoolCreateInfo *pCreateInfo, vk_alloc2(&device->vk.alloc, pAllocator, sizeof(*pool), 8, VK_SYSTEM_ALLOCATION_SCOPE_OBJECT); if (!pool) - return vk_error(device->instance, VK_ERROR_OUT_OF_HOST_MEMORY); + return vk_error(device, VK_ERROR_OUT_OF_HOST_MEMORY); vk_object_base_init(&device->vk, &pool->base, VK_OBJECT_TYPE_QUERY_POOL); @@ -987,13 +987,13 @@ radv_CreateQueryPool(VkDevice _device, const VkQueryPoolCreateInfo *pCreateInfo, RADV_BO_PRIORITY_QUERY_POOL, 0, &pool->bo); if (result != VK_SUCCESS) { radv_destroy_query_pool(device, pAllocator, pool); - return vk_error(device->instance, result); + return vk_error(device, result); } pool->ptr = device->ws->buffer_map(pool->bo); if (!pool->ptr) { radv_destroy_query_pool(device, pAllocator, pool); - return vk_error(device->instance, VK_ERROR_OUT_OF_DEVICE_MEMORY); + return vk_error(device, VK_ERROR_OUT_OF_DEVICE_MEMORY); } *pQueryPool = radv_query_pool_to_handle(pool); diff --git a/src/amd/vulkan/radv_shader.c b/src/amd/vulkan/radv_shader.c index e174d7a3b77..8044b78988b 100644 --- a/src/amd/vulkan/radv_shader.c +++ b/src/amd/vulkan/radv_shader.c @@ -1835,7 +1835,7 @@ radv_GetShaderInfoAMD(VkDevice _device, VkPipeline _pipeline, VkShaderStageFlagB /* Spec doesn't indicate what to do if the stage is invalid, so just * return no info for this. */ if (!variant) - return vk_error(device->instance, VK_ERROR_FEATURE_NOT_PRESENT); + return vk_error(device, VK_ERROR_FEATURE_NOT_PRESENT); switch (infoType) { case VK_SHADER_INFO_TYPE_STATISTICS_AMD: diff --git a/src/amd/vulkan/radv_util.c b/src/amd/vulkan/radv_util.c index ade0ffeaaa6..b8d3a22493a 100644 --- a/src/amd/vulkan/radv_util.c +++ b/src/amd/vulkan/radv_util.c @@ -71,48 +71,3 @@ radv_logi_v(const char *format, va_list va) vfprintf(stderr, format, va); fprintf(stderr, "\n"); } - -VkResult -__vk_errorv(struct radv_instance *instance, const void *object, VkDebugReportObjectTypeEXT type, - VkResult error, const char *file, int line, const char *format, va_list ap) -{ - char buffer[256]; - char report[512]; - - const char *error_str = vk_Result_to_str(error); - -#ifndef DEBUG - if (instance && !(instance->debug_flags & RADV_DEBUG_ERRORS)) - return error; -#endif - - if (format) { - vsnprintf(buffer, sizeof(buffer), format, ap); - - snprintf(report, sizeof(report), "%s:%d: %s (%s)", file, line, buffer, error_str); - } else { - snprintf(report, sizeof(report), "%s:%d: %s", file, line, error_str); - } - - if (instance) { - vk_debug_report(&instance->vk, VK_DEBUG_REPORT_ERROR_BIT_EXT, object, line, 0, "radv", - report); - } - - fprintf(stderr, "%s\n", report); - - return error; -} - -VkResult -__vk_errorf(struct radv_instance *instance, const void *object, VkDebugReportObjectTypeEXT type, - VkResult error, const char *file, int line, const char *format, ...) -{ - va_list ap; - - va_start(ap, format); - __vk_errorv(instance, object, type, error, file, line, format, ap); - va_end(ap); - - return error; -}