Attachment 141010 Details for Bug 103241 – Reproducer

Reproducer

vertex-input-64bit.c (text/plain), 43.50 KB, created by Józef Kucia on 2018-08-08 16:01:39 UTC

(hide)

Description:

Filename:

MIME Type:

Creator: Józef Kucia

Created: 2018-08-08 16:01:39 UTC

Size: 43.50 KB

patch

obsolete

>/*
> * gcc -lvulkan vertex-input-64bit.c -o vertex-input-64bit
> */
>#include <assert.h>
>#include <stdbool.h>
>#include <stdio.h>
>#include <stdlib.h>
>#include <string.h>
>
>#define VK_USE_PLATFORM_XCB_KHR
>
>#include <vulkan/vulkan.h>
>
>#define ARRAY_SIZE(x) (sizeof(x) / sizeof(*x))
>
>static const char * const instance_extensions[] =
>{
>    VK_KHR_SURFACE_EXTENSION_NAME,
>    VK_KHR_XCB_SURFACE_EXTENSION_NAME,
>};
>
>static const char * const device_extensions[] =
>{
>    VK_KHR_SWAPCHAIN_EXTENSION_NAME,
>};
>
>static VkInstance create_instance(void)
>{
>    VkApplicationInfo application_info;
>    VkInstanceCreateInfo instance_info;
>    VkInstance instance;
>    VkResult vr;
>
>    application_info.sType = VK_STRUCTURE_TYPE_APPLICATION_INFO;
>    application_info.pNext = NULL;
>    application_info.pApplicationName = "vk-dump-shader";
>    application_info.applicationVersion = 0;
>    application_info.pEngineName = NULL;
>    application_info.engineVersion = 0;
>    application_info.apiVersion = VK_API_VERSION_1_0;
>
>    instance_info.sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO;
>    instance_info.pNext = NULL;
>    instance_info.flags = 0;
>    instance_info.pApplicationInfo = &application_info;
>    instance_info.enabledLayerCount = 0;
>    instance_info.ppEnabledLayerNames = NULL;
>    instance_info.enabledExtensionCount = ARRAY_SIZE(instance_extensions);
>    instance_info.ppEnabledExtensionNames = instance_extensions;
>
>    if ((vr = vkCreateInstance(&instance_info, NULL, &instance)))
>    {
>        fprintf(stderr, "Failed to create Vulkan instance, vr %d.\n", vr);
>        return VK_NULL_HANDLE;
>    }
>    return instance;
>}
>
>static VkPhysicalDevice select_physical_device(VkInstance instance)
>{
>    VkPhysicalDevice *physical_devices, selected_device;
>    uint32_t count;
>    unsigned int i;
>    VkResult vr;
>
>    count = 0;
>    if ((vr = vkEnumeratePhysicalDevices(instance, &count, NULL)) < 0)
>    {
>        fprintf(stderr, "Failed to enumerate physical devices, vr %d.\n", vr);
>        return VK_NULL_HANDLE;
>    }
>    if (!count)
>    {
>        fprintf(stderr, "No physical device available.\n");
>        return VK_NULL_HANDLE;
>    }
>    if (!(physical_devices = calloc(count, sizeof(*physical_devices))))
>        return VK_NULL_HANDLE;
>
>    if ((vr = vkEnumeratePhysicalDevices(instance, &count, physical_devices)) < 0)
>    {
>        fprintf(stderr, "Failed to enumerate physical devices, vr %d.\n", vr);
>        free(physical_devices);
>        return VK_NULL_HANDLE;
>    }
>
>    selected_device = physical_devices[0];
>    free(physical_devices);
>    return selected_device;
>}
>
>static VkDevice create_device(VkInstance instance, VkPhysicalDevice physical_device)
>{
>    VkQueueFamilyProperties *queue_properties;
>    VkPhysicalDeviceFeatures device_features;
>    VkDeviceQueueCreateInfo *queue_info;
>    VkDeviceCreateInfo device_info;
>    uint32_t queue_family_count;
>    VkDevice device;
>    unsigned int i;
>    VkResult vr;
>
>    vkGetPhysicalDeviceQueueFamilyProperties(physical_device, &queue_family_count, NULL);
>    if (!(queue_properties = calloc(queue_family_count, sizeof(*queue_properties))))
>        return VK_NULL_HANDLE;
>    vkGetPhysicalDeviceQueueFamilyProperties(physical_device, &queue_family_count, queue_properties);
>
>    if (!(queue_info = calloc(queue_family_count, sizeof(*queue_info))))
>    {
>        free(queue_properties);
>        return VK_NULL_HANDLE;
>    }
>
>    for (i = 0; i < queue_family_count; ++i)
>    {
>        static float priorities[] = {1.0f};
>
>        queue_info[i].sType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO;
>        queue_info[i].pNext = NULL;
>        queue_info[i].flags = 0;
>        queue_info[i].queueFamilyIndex = i;
>        queue_info[i].queueCount = 1;
>        queue_info[i].pQueuePriorities = priorities;
>    }
>    free(queue_properties);
>
>    vkGetPhysicalDeviceFeatures(physical_device, &device_features);
>
>    device_info.sType = VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO;
>    device_info.pNext = NULL;
>    device_info.flags = 0;
>    device_info.queueCreateInfoCount = queue_family_count;
>    device_info.pQueueCreateInfos = queue_info;
>    device_info.enabledLayerCount = 0;
>    device_info.ppEnabledLayerNames = NULL;
>    device_info.enabledExtensionCount = ARRAY_SIZE(device_extensions);
>    device_info.ppEnabledExtensionNames = device_extensions;
>    device_info.pEnabledFeatures = &device_features;
>
>    vr = vkCreateDevice(physical_device, &device_info, NULL, &device);
>    free(queue_info);
>    if (vr < 0)
>    {
>        fprintf(stderr, "Failed to create Vulkan device, vr %d.\n", vr);
>        return VK_NULL_HANDLE;
>    }
>    return device;
>}
>
>static VkShaderModule create_shader_module(VkDevice device, size_t size, const void *code)
>{
>    VkShaderModuleCreateInfo create_info;
>    VkShaderModule module;
>    VkResult vr;
>
>    memset(&create_info, 0, sizeof(create_info));
>    create_info.sType = VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO;
>    create_info.codeSize = size;
>    create_info.pCode = code;
>    if ((vr = vkCreateShaderModule(device, &create_info, NULL, &module)) < 0)
>    {
>        fprintf(stderr, "Failed to create shader module, vr %d.\n", vr);
>        return VK_NULL_HANDLE;
>    }
>    return module;
>}
>
>static VkPipeline create_graphics_pipeline(VkDevice device, VkPipelineLayout layout,
>        VkShaderModule vs, VkShaderModule fs, VkRenderPass render_pass)
>{
>    VkPipelineRasterizationStateCreateInfo rasterization_state;
>    VkPipelineMultisampleStateCreateInfo multisample_state;
>    VkPipelineInputAssemblyStateCreateInfo input_assembly;
>    VkPipelineColorBlendAttachmentState blend_attachment;
>    VkPipelineShaderStageCreateInfo stage_create_info[2];
>    VkVertexInputAttributeDescription input_attribs[4];
>    VkVertexInputBindingDescription input_bindings[1];
>    VkPipelineVertexInputStateCreateInfo vertex_input;
>    VkPipelineViewportStateCreateInfo viewport_state;
>    VkPipelineColorBlendStateCreateInfo blend_state;
>    VkGraphicsPipelineCreateInfo create_info;
>    VkViewport viewports[1];
>    VkRect2D scissors[1];
>    VkPipeline pipeline;
>    VkResult vr;
>
>    memset(stage_create_info, 0, sizeof(stage_create_info));
>    stage_create_info[0].sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO;
>    stage_create_info[0].stage = VK_SHADER_STAGE_VERTEX_BIT;
>    stage_create_info[0].module = vs;
>    stage_create_info[0].pName = "main";
>    stage_create_info[1].sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO;
>    stage_create_info[1].stage = VK_SHADER_STAGE_FRAGMENT_BIT;
>    stage_create_info[1].module = fs;
>    stage_create_info[1].pName = "main";
>
>    memset(input_bindings, 0, sizeof(input_bindings));
>
>    memset(input_attribs, 0, sizeof(input_attribs));
>    input_attribs[0].location = 0;
>    input_attribs[0].offset = 0;
>    input_attribs[0].format = VK_FORMAT_R64G64B64A64_SFLOAT;
>    input_attribs[1].location = 2;
>    input_attribs[1].offset = 32;
>    input_attribs[1].format = VK_FORMAT_R64G64B64A64_SFLOAT;
>    input_attribs[2].location = 4;
>    input_attribs[2].offset = 64;
>    input_attribs[2].format = VK_FORMAT_R64G64B64A64_SFLOAT;
>    input_attribs[3].location = 6;
>    input_attribs[3].offset = 96;
>    input_attribs[3].format = VK_FORMAT_R64G64B64A64_SFLOAT;
>
>    memset(&vertex_input, 0, sizeof(vertex_input));
>    vertex_input.sType = VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO;
>    vertex_input.vertexBindingDescriptionCount = ARRAY_SIZE(input_bindings);
>    vertex_input.pVertexBindingDescriptions = input_bindings;
>    vertex_input.vertexAttributeDescriptionCount = ARRAY_SIZE(input_attribs);
>    vertex_input.pVertexAttributeDescriptions = input_attribs;
>
>    memset(&input_assembly, 0, sizeof(input_assembly));
>    input_assembly.sType = VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO;
>    input_assembly.topology = VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST;
>
>    viewports[0].x = 0.0f;
>    viewports[0].y = 0.0f;
>    viewports[0].width = 32.0f;
>    viewports[0].height = 32.0f;
>    viewports[0].minDepth = 0.0f;
>    viewports[0].maxDepth = 1.0f;
>    scissors[0].offset.x = 0;
>    scissors[0].offset.y = 0;
>    scissors[0].extent.width = 32;
>    scissors[0].extent.height = 32;
>    memset(&viewport_state, 0, sizeof(viewport_state));
>    viewport_state.sType = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO;
>    viewport_state.viewportCount = 1;
>    viewport_state.pViewports = viewports;
>    viewport_state.scissorCount = 1;
>    viewport_state.pScissors = scissors;
>
>    memset(&rasterization_state, 0, sizeof(rasterization_state));
>    rasterization_state.sType = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO;
>    rasterization_state.polygonMode = VK_POLYGON_MODE_FILL;
>    rasterization_state.cullMode = VK_CULL_MODE_NONE;
>    rasterization_state.frontFace = VK_FRONT_FACE_COUNTER_CLOCKWISE;
>    rasterization_state.lineWidth = 1.0f;
>
>    memset(&multisample_state, 0, sizeof(multisample_state));
>    multisample_state.sType = VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO;
>    multisample_state.rasterizationSamples = VK_SAMPLE_COUNT_1_BIT;
>
>    memset(&blend_attachment, 0, sizeof(blend_attachment));
>    blend_attachment.colorWriteMask = VK_COLOR_COMPONENT_R_BIT | VK_COLOR_COMPONENT_G_BIT
>            | VK_COLOR_COMPONENT_B_BIT | VK_COLOR_COMPONENT_A_BIT;
>    memset(&blend_state, 0, sizeof(blend_state));
>    blend_state.sType = VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO;
>    blend_state.attachmentCount = 1;
>    blend_state.pAttachments = &blend_attachment;
>
>    memset(&create_info, 0, sizeof(create_info));
>    create_info.sType = VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO;
>    create_info.stageCount = 2;
>    create_info.pStages = stage_create_info;
>    create_info.pVertexInputState = &vertex_input;
>    create_info.pInputAssemblyState = &input_assembly;
>    create_info.pViewportState = &viewport_state;
>    create_info.pRasterizationState = &rasterization_state;
>    create_info.pMultisampleState = &multisample_state;
>    create_info.pColorBlendState = &blend_state;
>    create_info.layout = layout;
>    create_info.renderPass = render_pass;
>    create_info.basePipelineIndex = -1;
>
>    if ((vr = vkCreateGraphicsPipelines(device, VK_NULL_HANDLE,
>            1, &create_info, NULL, &pipeline)) < 0)
>    {
>        fprintf(stderr, "Failed to create pipeline, vr %d.\n", vr);
>        return VK_NULL_HANDLE;
>    }
>    return pipeline;
>}
>
>static VkRenderPass create_render_pass(VkDevice device)
>{
>    VkAttachmentReference attachment_ref;
>    VkAttachmentDescription attachment;
>    VkRenderPassCreateInfo pass_info;
>    VkSubpassDescription subpass;
>    VkRenderPass render_pass;
>    VkResult vr;
>
>    memset(&attachment, 0, sizeof(attachment));
>    attachment.format = VK_FORMAT_R32G32B32A32_SFLOAT;
>    attachment.samples = VK_SAMPLE_COUNT_1_BIT;
>    attachment.initialLayout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
>    attachment.finalLayout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
>
>    attachment_ref.attachment = 0;
>    attachment_ref.layout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
>
>    memset(&subpass, 0, sizeof(subpass));
>    subpass.flags = 0;
>    subpass.pipelineBindPoint = VK_PIPELINE_BIND_POINT_GRAPHICS;
>    subpass.colorAttachmentCount = 1;
>    subpass.pColorAttachments = &attachment_ref;
>
>    memset(&pass_info, 0, sizeof(pass_info));
>    pass_info.sType = VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO;
>    pass_info.attachmentCount = 1;
>    pass_info.pAttachments = &attachment;
>    pass_info.subpassCount = 1;
>    pass_info.pSubpasses = &subpass;
>
>    if ((vr = vkCreateRenderPass(device, &pass_info, NULL, &render_pass)) < 0)
>    {
>        fprintf(stderr, "Failed to create render pass, vr %d.\n", vr);
>        return VK_NULL_HANDLE;
>    }
>    return render_pass;
>}
>
>static VkDescriptorSetLayout create_descriptor_set_layout(VkDevice device)
>{
>    VkDescriptorSetLayoutCreateInfo create_info;
>    VkDescriptorSetLayoutBinding bindings[2];
>    VkDescriptorSetLayout layout;
>    unsigned int i;
>    VkResult vr;
>
>    create_info.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO;
>    create_info.pNext = NULL;
>    create_info.flags = 0;
>    create_info.bindingCount = ARRAY_SIZE(bindings);
>    create_info.pBindings = bindings;
>
>    for (i = 0; i < ARRAY_SIZE(bindings); ++i)
>    {
>        bindings[i].binding = i;
>        bindings[i].descriptorType = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER;
>        bindings[i].descriptorCount = 1;
>        bindings[i].stageFlags = VK_SHADER_STAGE_FRAGMENT_BIT;
>        bindings[i].pImmutableSamplers = NULL;
>    }
>
>    if ((vr = vkCreateDescriptorSetLayout(device, &create_info, NULL, &layout) < 0))
>    {
>        fprintf(stderr, "Failed to create descriptor set, vr %d.\n", vr);
>        return VK_NULL_HANDLE;
>    }
>    return layout;
>}
>
>static VkDescriptorPool create_descriptor_pool(VkDevice device)
>{
>    VkDescriptorPoolCreateInfo create_info;
>    VkDescriptorPoolSize pool_sizes[2];
>    VkDescriptorPool pool;
>    VkResult vr;
>
>    create_info.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO;
>    create_info.pNext = NULL;
>    create_info.flags = 0;
>    create_info.maxSets = 32;
>    create_info.poolSizeCount = ARRAY_SIZE(pool_sizes);
>    create_info.pPoolSizes = pool_sizes;
>
>    pool_sizes[0].type = VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER;
>    pool_sizes[0].descriptorCount = 32;
>    pool_sizes[1].type = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER;
>    pool_sizes[1].descriptorCount = 32;
>
>    if ((vr = vkCreateDescriptorPool(device, &create_info, NULL, &pool)) < 0)
>    {
>        fprintf(stderr, "Failed to create descriptor pool, vr %d.\n", vr);
>        return VK_NULL_HANDLE;
>    }
>    return pool;
>}
>
>static VkDescriptorSet allocate_descriptor_set(VkDevice device,
>        VkDescriptorPool pool, VkDescriptorSetLayout set_layout)
>{
>    VkDescriptorSetAllocateInfo allocate_info;
>    VkDescriptorSet set;
>    VkResult vr;
>
>    allocate_info.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO;
>    allocate_info.pNext = NULL;
>    allocate_info.descriptorPool = pool;
>    allocate_info.descriptorSetCount = 1;
>    allocate_info.pSetLayouts = &set_layout;
>
>    if ((vr = vkAllocateDescriptorSets(device, &allocate_info, &set)) < 0)
>    {
>        fprintf(stderr, "Failed to allocate descriptor set, vr %d.\n", vr);
>        return VK_NULL_HANDLE;
>    }
>    return set;
>}
>
>static VkPipelineLayout create_pipeline_layout(VkDevice device,
>        VkDescriptorSetLayout set_layout)
>{
>    VkPipelineLayoutCreateInfo create_info;
>    VkPipelineLayout layout;
>    VkResult vr;
>
>    memset(&create_info, 0, sizeof(create_info));
>    create_info.sType = VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO;
>    if (set_layout)
>    {
>        create_info.setLayoutCount = 1;
>        create_info.pSetLayouts = &set_layout;
>    }
>
>    if ((vr = vkCreatePipelineLayout(device, &create_info, NULL, &layout)) < 0)
>    {
>        fprintf(stderr, "Failed to create pipeline layout, vr %d.\n", vr);
>        return VK_NULL_HANDLE;
>    }
>    return layout;
>}
>
>static VkCommandPool create_command_pool(VkDevice device, uint32_t queue_index)
>{
>    VkCommandPoolCreateInfo create_info;
>    VkCommandPool pool;
>    VkResult vr;
>
>    create_info.sType = VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO;
>    create_info.pNext = NULL;
>    create_info.flags = 0;
>    create_info.queueFamilyIndex = queue_index;
>
>    if ((vr = vkCreateCommandPool(device, &create_info, NULL, &pool)) < 0)
>    {
>        fprintf(stderr, "Failed to create command pool, vr %d.\n", vr);
>        return VK_NULL_HANDLE;
>    }
>    return pool;
>}
>
>static VkCommandBuffer allocate_command_buffer(VkDevice device, VkCommandPool pool)
>{
>    VkCommandBufferAllocateInfo allocate_info;
>    VkCommandBuffer command_buffer;
>    VkResult vr;
>
>    allocate_info.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO;
>    allocate_info.pNext = NULL;
>    allocate_info.commandPool = pool;
>    allocate_info.level = VK_COMMAND_BUFFER_LEVEL_PRIMARY;
>    allocate_info.commandBufferCount = 1;
>
>    if ((vr = vkAllocateCommandBuffers(device, &allocate_info, &command_buffer)) < 0)
>    {
>        fprintf(stderr, "Failed to allocate command buffer, vr %d.\n", vr);
>        return VK_NULL_HANDLE;
>    }
>    return command_buffer;
>}
>
>static void begin_command_buffer(VkCommandBuffer command_buffer)
>{
>    VkCommandBufferBeginInfo begin_info;
>    VkResult vr;
>
>    begin_info.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO;
>    begin_info.pNext = NULL;
>    begin_info.flags = 0;
>    begin_info.pInheritanceInfo = NULL;
>
>    if ((vr = vkBeginCommandBuffer(command_buffer, &begin_info)) < 0)
>    {
>        fprintf(stderr, "Failed to begin command buffer, vr %d.\n", vr);
>    }
>    assert(vr == VK_SUCCESS);
>}
>
>static void end_command_buffer(VkCommandBuffer command_buffer)
>{
>    VkResult vr;
>
>    if ((vr = vkEndCommandBuffer(command_buffer)) < 0)
>    {
>        fprintf(stderr, "Failed to end command buffer, vr %d.\n", vr);
>    }
>    assert(vr == VK_SUCCESS);
>}
>
>static void submit_commands(VkDevice device,
>        VkQueue queue, VkCommandBuffer command_buffer, bool wait)
>{
>    VkFenceCreateInfo create_info;
>    VkSubmitInfo submit_info;
>    VkFence fence;
>    VkResult vr;
>
>    fence = VK_NULL_HANDLE;
>    if (wait)
>    {
>        create_info.sType = VK_STRUCTURE_TYPE_FENCE_CREATE_INFO;
>        create_info.pNext = NULL;
>        create_info.flags = 0;
>
>        if ((vr = vkCreateFence(device, &create_info, NULL, &fence)) < 0)
>        {
>            fprintf(stderr, "Failed to create fence, vr %d.\n", vr);
>            return;
>        }
>    }
>
>    memset(&submit_info, 0, sizeof(submit_info));
>    submit_info.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO;
>    submit_info.pNext = NULL;
>    submit_info.commandBufferCount = 1;
>    submit_info.pCommandBuffers = &command_buffer;
>
>    if ((vr = vkQueueSubmit(queue, 1, &submit_info, fence) < 0))
>    {
>        fprintf(stderr, "Failed to submit commands, vr %d.\n", vr);
>        vkDestroyFence(device, fence, NULL);
>        return;
>    }
>
>    if ((vr = vkWaitForFences(device, 1, &fence, VK_FALSE, ~0u)) < 0)
>    {
>        fprintf(stderr, "Failed to wait for fences, vr %d.\n", vr);
>        return;
>    }
>
>    vkDestroyFence(device, fence, NULL);
>}
>
>static VkBuffer create_buffer(VkDevice device,
>        VkDeviceSize size, VkBufferUsageFlags usage)
>{
>    VkBufferCreateInfo buffer_info;
>    VkBuffer buffer;
>    VkResult vr;
>
>    buffer_info.sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO;
>    buffer_info.pNext = NULL;
>    buffer_info.flags = 0;
>    buffer_info.size = size;
>    buffer_info.usage = usage;
>    buffer_info.sharingMode = VK_SHARING_MODE_EXCLUSIVE;
>    buffer_info.queueFamilyIndexCount = 0;
>    buffer_info.pQueueFamilyIndices = 0;
>
>    if ((vr = vkCreateBuffer(device, &buffer_info, NULL, &buffer)) < 0)
>    {
>        fprintf(stderr, "Failed to create Vulkan buffer, vr %d.\n", vr);
>        return VK_NULL_HANDLE;
>    }
>    return buffer;
>}
>
>static unsigned int select_memory_type(VkDevice device, VkPhysicalDevice physical_device,
>        uint32_t memory_type_mask, VkMemoryPropertyFlags required_flags)
>{
>    VkPhysicalDeviceMemoryProperties memory_info;
>    unsigned int i;
>
>    vkGetPhysicalDeviceMemoryProperties(physical_device, &memory_info);
>
>    for (i = 0; i < memory_info.memoryTypeCount; ++i)
>    {
>        if (!(memory_type_mask & (1u << i)))
>            continue;
>        if ((memory_info.memoryTypes[i].propertyFlags & required_flags) == required_flags)
>            return i;
>    }
>
>    return ~0u;
>}
>
>static VkDeviceMemory allocate_device_memory(VkDevice device, VkPhysicalDevice physical_device,
>        const VkMemoryRequirements *memory_requirements, VkMemoryPropertyFlags memory_flags)
>{
>    VkMemoryAllocateInfo allocate_info;
>    VkDeviceMemory vk_memory;
>    VkResult vr;
>
>    allocate_info.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO;
>    allocate_info.pNext = NULL;
>    allocate_info.allocationSize = memory_requirements->size;
>    allocate_info.memoryTypeIndex = select_memory_type(device, physical_device,
>            memory_requirements->memoryTypeBits, memory_flags);
>
>    if (allocate_info.memoryTypeIndex == ~0u)
>    {
>        fprintf(stderr, "Failed to find suitable memory type (allowed types %#x).\n",
>                memory_requirements->memoryTypeBits);
>        return VK_NULL_HANDLE;
>    }
>
>    if ((vr = vkAllocateMemory(device, &allocate_info, NULL, &vk_memory)) < 0)
>    {
>        fprintf(stderr, "Failed to allocate device memory, vr %d.\n", vr);
>        return VK_NULL_HANDLE;
>    }
>    return vk_memory;
>}
>
>static VkDeviceMemory allocate_buffer_memory(VkDevice device, VkPhysicalDevice physical_device,
>        VkBuffer buffer, VkMemoryPropertyFlags memory_flags)
>{
>    VkMemoryRequirements memory_requirements;
>    VkDeviceMemory memory;
>    VkResult vr;
>
>    vkGetBufferMemoryRequirements(device, buffer, &memory_requirements);
>    memory = allocate_device_memory(device, physical_device, &memory_requirements, memory_flags);
>    assert(memory != VK_NULL_HANDLE);
>
>    if ((vr = vkBindBufferMemory(device, buffer, memory, 0)) < 0)
>    {
>        fprintf(stderr, "Failed to bind memory, vr %d.\n", vr);
>        vkFreeMemory(device, memory, NULL);
>        return VK_NULL_HANDLE;
>    }
>    return memory;
>}
>
>static VkBufferView create_buffer_view(VkDevice device, VkBuffer buffer, VkFormat format)
>{
>    VkBufferViewCreateInfo create_info;
>    VkBufferView buffer_view;
>    VkResult vr;
>
>    create_info.sType = VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO;
>    create_info.pNext = NULL;
>    create_info.flags = 0;
>    create_info.buffer = buffer;
>    create_info.format = format;
>    create_info.offset = 0;
>    create_info.range = VK_WHOLE_SIZE;
>
>    if ((vr = vkCreateBufferView(device, &create_info, NULL, &buffer_view)) < 0)
>    {
>        fprintf(stderr, "Failed to create buffer view, vr %d.\n", vr);
>        return VK_NULL_HANDLE;
>    }
>    return buffer_view;
>}
>
>static VkImage create_image(VkDevice device, VkFormat format,
>        unsigned int width, unsigned int height, VkImageUsageFlags usage)
>{
>    VkImageCreateInfo image_info;
>    VkImage image;
>    VkResult vr;
>
>    image_info.sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO;
>    image_info.pNext = NULL;
>    image_info.flags = 0;
>    image_info.imageType = VK_IMAGE_TYPE_2D;
>    image_info.format = format;
>    image_info.extent.width = width;
>    image_info.extent.height = height;
>    image_info.extent.depth = 1;
>    image_info.arrayLayers = 1;
>    image_info.mipLevels = 1;
>    image_info.samples = VK_SAMPLE_COUNT_1_BIT;
>    image_info.tiling = VK_IMAGE_TILING_OPTIMAL;
>    image_info.usage = usage;
>    image_info.sharingMode = VK_SHARING_MODE_EXCLUSIVE;
>    image_info.queueFamilyIndexCount = 0;
>    image_info.pQueueFamilyIndices = NULL;
>    image_info.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED;
>
>    if ((vr = vkCreateImage(device, &image_info, NULL, &image)) < 0)
>    {
>        fprintf(stderr, "Failed to create Vulkan image, vr %d.\n", vr);
>        return VK_NULL_HANDLE;
>    }
>    return image;
>}
>
>static VkDeviceMemory allocate_image_memory(VkDevice device, VkPhysicalDevice physical_device,
>        VkImage image, VkMemoryPropertyFlags memory_flags)
>{
>    VkMemoryRequirements memory_requirements;
>    VkDeviceMemory memory;
>    VkResult vr;
>
>    vkGetImageMemoryRequirements(device, image, &memory_requirements);
>    memory = allocate_device_memory(device, physical_device, &memory_requirements, memory_flags);
>    assert(memory != VK_NULL_HANDLE);
>
>    if ((vr = vkBindImageMemory(device, image, memory, 0)) < 0)
>    {
>        fprintf(stderr, "Failed to bind memory, vr %d.\n", vr);
>        vkFreeMemory(device, memory, NULL);
>        return VK_NULL_HANDLE;
>    }
>    return memory;
>}
>
>static VkImageView create_image_view(VkDevice device, VkImage image, VkFormat format)
>{
>    VkImageViewCreateInfo create_info;
>    VkImageView image_view;
>    VkResult vr;
>
>    create_info.sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO;
>    create_info.pNext = NULL;
>    create_info.flags = 0;
>    create_info.image = image;
>    create_info.viewType = VK_IMAGE_VIEW_TYPE_2D;
>    create_info.format = format;
>    create_info.components.r = VK_COMPONENT_SWIZZLE_IDENTITY;
>    create_info.components.g = VK_COMPONENT_SWIZZLE_IDENTITY;
>    create_info.components.b = VK_COMPONENT_SWIZZLE_IDENTITY;
>    create_info.components.a = VK_COMPONENT_SWIZZLE_IDENTITY;
>    create_info.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
>    create_info.subresourceRange.baseMipLevel = 0;
>    create_info.subresourceRange.levelCount = VK_REMAINING_MIP_LEVELS;
>    create_info.subresourceRange.baseArrayLayer = 0;
>    create_info.subresourceRange.layerCount = VK_REMAINING_ARRAY_LAYERS;
>
>    if ((vr = vkCreateImageView(device, &create_info, NULL, &image_view)) < 0)
>    {
>        fprintf(stderr, "Failed to create image view, vr %d.\n", vr);
>        return VK_NULL_HANDLE;
>    }
>    return image_view;
>}
>
>static VkFramebuffer create_framebuffer(VkDevice device,
>        VkRenderPass render_pass, VkImageView image_view, unsigned int width, unsigned int height)
>{
>    VkFramebufferCreateInfo create_info;
>    VkFramebuffer framebuffer;
>    VkResult vr;
>
>    create_info.sType = VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO;
>    create_info.pNext = NULL;
>    create_info.flags = 0;
>    create_info.renderPass = render_pass;
>    create_info.attachmentCount = 1;
>    create_info.pAttachments = &image_view;
>    create_info.width = width;
>    create_info.height = height;
>    create_info.layers = 1;
>
>    if ((vr = vkCreateFramebuffer(device, &create_info, NULL, &framebuffer)) < 0)
>    {
>        fprintf(stderr, "Failed to create framebuffer, vr %d.\n", vr);
>        return VK_NULL_HANDLE;
>    }
>    return framebuffer;
>}
>
>static void cmd_buffer_barrier(VkCommandBuffer command_buffer, VkBuffer buffer,
>        VkPipelineStageFlags src_stage_mask, VkPipelineStageFlags dst_stage_mask,
>        VkAccessFlags src_access_mask, VkAccessFlags dst_access_mask)
>{
>    VkBufferMemoryBarrier buffer_barrier;
>
>    buffer_barrier.sType = VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER;
>    buffer_barrier.pNext = NULL;
>    buffer_barrier.srcAccessMask = src_access_mask;
>    buffer_barrier.dstAccessMask = dst_access_mask;
>    buffer_barrier.srcQueueFamilyIndex = 0;
>    buffer_barrier.dstQueueFamilyIndex = 0;
>    buffer_barrier.buffer = buffer;
>    buffer_barrier.offset = 0;
>    buffer_barrier.size = VK_WHOLE_SIZE;
>
>    vkCmdPipelineBarrier(command_buffer, src_stage_mask, dst_stage_mask, 0,
>            0, NULL, 1, &buffer_barrier, 0, NULL);
>}
>
>static void cmd_image_barrier(VkCommandBuffer command_buffer, VkImage image,
>        VkPipelineStageFlags src_stage_mask, VkPipelineStageFlags dst_stage_mask,
>        VkAccessFlags src_access_mask, VkAccessFlags dst_access_mask,
>        VkImageLayout old_layout, VkImageLayout new_layout)
>{
>    VkImageMemoryBarrier image_barrier;
>
>    image_barrier.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER;
>    image_barrier.pNext = NULL;
>    image_barrier.srcAccessMask = src_access_mask;
>    image_barrier.dstAccessMask = dst_access_mask;
>    image_barrier.oldLayout = old_layout;
>    image_barrier.newLayout = new_layout;
>    image_barrier.srcQueueFamilyIndex = 0;
>    image_barrier.dstQueueFamilyIndex = 0;
>    image_barrier.image = image;
>    image_barrier.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
>    image_barrier.subresourceRange.baseMipLevel = 0;
>    image_barrier.subresourceRange.levelCount = VK_REMAINING_MIP_LEVELS;
>    image_barrier.subresourceRange.baseArrayLayer = 0;
>    image_barrier.subresourceRange.layerCount = VK_REMAINING_ARRAY_LAYERS;
>
>    vkCmdPipelineBarrier(command_buffer, src_stage_mask, dst_stage_mask, 0,
>            0, NULL, 0, NULL, 1, &image_barrier);
>}
>
>static void cmd_copy_buffer(VkCommandBuffer command_buffer,
>        VkBuffer src_buffer, VkBuffer dst_buffer,
>        VkDeviceSize src_offset, VkDeviceSize dst_offset, VkDeviceSize size)
>{
>    VkBufferCopy region;
>
>    region.srcOffset = src_offset;
>    region.dstOffset = dst_offset;
>    region.size = size;
>
>    vkCmdCopyBuffer(command_buffer, src_buffer, dst_buffer, 1, &region);
>}
>
>static void cmd_copy_image_to_buffer(VkCommandBuffer command_buffer,
>        VkImage src_image, VkImageLayout image_layout, VkBuffer dst_buffer,
>        unsigned int width, unsigned int height)
>{
>    VkBufferImageCopy region;
>
>    region.bufferOffset = 0;
>    region.bufferRowLength = 0;
>    region.bufferImageHeight = 0;
>    region.imageSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
>    region.imageSubresource.mipLevel = 0;
>    region.imageSubresource.baseArrayLayer = 0;
>    region.imageSubresource.layerCount = 1;
>    region.imageOffset.x = 0;
>    region.imageOffset.y = 0;
>    region.imageOffset.z = 0;
>    region.imageExtent.width = width;
>    region.imageExtent.height = height;
>    region.imageExtent.depth = 0;
>    vkCmdCopyImageToBuffer(command_buffer, src_image, image_layout, dst_buffer, 1, &region);
>}
>
>static void cmd_clear_color_attachment(VkCommandBuffer command_buffer,
>        unsigned int index, unsigned int width, unsigned int height,
>        float r, float g, float b, float a)
>{
>    VkClearAttachment attachment;
>    VkClearRect rect;
>
>    attachment.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
>    attachment.colorAttachment = index;
>    attachment.clearValue.color.float32[0] = r;
>    attachment.clearValue.color.float32[1] = g;
>    attachment.clearValue.color.float32[2] = b;
>    attachment.clearValue.color.float32[3] = a;
>
>    rect.rect.offset.x = 0;
>    rect.rect.offset.y = 0;
>    rect.rect.extent.width = width;
>    rect.rect.extent.height = height;
>    rect.baseArrayLayer = 0;
>    rect.layerCount = 1;
>
>    vkCmdClearAttachments(command_buffer, 1, &attachment, 1, &rect);
>}
>
>static void cmd_begin_render_pass(VkCommandBuffer command_buffer,
>        VkRenderPass render_pass, VkFramebuffer framebuffer, unsigned int width, unsigned int height)
>{
>    struct VkRenderPassBeginInfo begin_desc;
>
>    begin_desc.sType = VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO;
>    begin_desc.pNext = NULL;
>    begin_desc.renderPass = render_pass;
>    begin_desc.framebuffer = framebuffer;
>    begin_desc.renderArea.offset.x = 0;
>    begin_desc.renderArea.offset.y = 0;
>    begin_desc.renderArea.extent.width = width;
>    begin_desc.renderArea.extent.height = height;
>    begin_desc.clearValueCount = 0;
>    begin_desc.pClearValues = NULL;
>    vkCmdBeginRenderPass(command_buffer, &begin_desc, VK_SUBPASS_CONTENTS_INLINE);
>}
>
>static void *map_memory(VkDevice device, VkDeviceMemory memory,
>        VkDeviceSize offset, VkDeviceSize size)
>{
>    VkResult vr;
>    void *ptr;
>
>    if ((vr = vkMapMemory(device, memory, offset, size, 0, &ptr)) < 0)
>    {
>        fprintf(stderr, "Failed to map memory, vr %d.\n", vr);
>        return NULL;
>    }
>    return ptr;
>}
>
>static uint32_t vs_code[] =
>{
>#if 0
>    #version 450
>    layout(location=0) in dmat4 x;
>    void main()
>    {
>        gl_Position = vec4(x[0][0]);
>    }
>#endif
>    0x07230203, 0x00010000, 0x00080007, 0x0000001d, 0x00000000, 0x00020011, 0x00000001, 0x00020011,
>    0x0000000a, 0x0006000b, 0x00000001, 0x4c534c47, 0x6474732e, 0x3035342e, 0x00000000, 0x0003000e,
>    0x00000000, 0x00000001, 0x0007000f, 0x00000000, 0x00000004, 0x6e69616d, 0x00000000, 0x0000000d,
>    0x00000014, 0x00030003, 0x00000002, 0x000001c2, 0x00040005, 0x00000004, 0x6e69616d, 0x00000000,
>    0x00060005, 0x0000000b, 0x505f6c67, 0x65567265, 0x78657472, 0x00000000, 0x00060006, 0x0000000b,
>    0x00000000, 0x505f6c67, 0x7469736f, 0x006e6f69, 0x00070006, 0x0000000b, 0x00000001, 0x505f6c67,
>    0x746e696f, 0x657a6953, 0x00000000, 0x00070006, 0x0000000b, 0x00000002, 0x435f6c67, 0x4470696c,
>    0x61747369, 0x0065636e, 0x00070006, 0x0000000b, 0x00000003, 0x435f6c67, 0x446c6c75, 0x61747369,
>    0x0065636e, 0x00030005, 0x0000000d, 0x00000000, 0x00030005, 0x00000014, 0x00000078, 0x00050048,
>    0x0000000b, 0x00000000, 0x0000000b, 0x00000000, 0x00050048, 0x0000000b, 0x00000001, 0x0000000b,
>    0x00000001, 0x00050048, 0x0000000b, 0x00000002, 0x0000000b, 0x00000003, 0x00050048, 0x0000000b,
>    0x00000003, 0x0000000b, 0x00000004, 0x00030047, 0x0000000b, 0x00000002, 0x00040047, 0x00000014,
>    0x0000001e, 0x00000000, 0x00020013, 0x00000002, 0x00030021, 0x00000003, 0x00000002, 0x00030016,
>    0x00000006, 0x00000020, 0x00040017, 0x00000007, 0x00000006, 0x00000004, 0x00040015, 0x00000008,
>    0x00000020, 0x00000000, 0x0004002b, 0x00000008, 0x00000009, 0x00000001, 0x0004001c, 0x0000000a,
>    0x00000006, 0x00000009, 0x0006001e, 0x0000000b, 0x00000007, 0x00000006, 0x0000000a, 0x0000000a,
>    0x00040020, 0x0000000c, 0x00000003, 0x0000000b, 0x0004003b, 0x0000000c, 0x0000000d, 0x00000003,
>    0x00040015, 0x0000000e, 0x00000020, 0x00000001, 0x0004002b, 0x0000000e, 0x0000000f, 0x00000000,
>    0x00030016, 0x00000010, 0x00000040, 0x00040017, 0x00000011, 0x00000010, 0x00000004, 0x00040018,
>    0x00000012, 0x00000011, 0x00000004, 0x00040020, 0x00000013, 0x00000001, 0x00000012, 0x0004003b,
>    0x00000013, 0x00000014, 0x00000001, 0x0004002b, 0x00000008, 0x00000015, 0x00000000, 0x00040020,
>    0x00000016, 0x00000001, 0x00000010, 0x00040020, 0x0000001b, 0x00000003, 0x00000007, 0x00050036,
>    0x00000002, 0x00000004, 0x00000000, 0x00000003, 0x000200f8, 0x00000005, 0x00060041, 0x00000016,
>    0x00000017, 0x00000014, 0x0000000f, 0x00000015, 0x0004003d, 0x00000010, 0x00000018, 0x00000017,
>    0x00040073, 0x00000006, 0x00000019, 0x00000018, 0x00070050, 0x00000007, 0x0000001a, 0x00000019,
>    0x00000019, 0x00000019, 0x00000019, 0x00050041, 0x0000001b, 0x0000001c, 0x0000000d, 0x0000000f,
>    0x0003003e, 0x0000001c, 0x0000001a, 0x000100fd, 0x00010038,
>};
>
>static uint32_t fs_code[] =
>{
>#if 0
>    ; SPIR-V
>    ; Version: 1.0
>    ; Generator: Khronos; 0
>    ; Bound: 85
>    ; Schema: 0
>    OpCapability Shader
>    OpMemoryModel Logical GLSL450
>    OpEntryPoint Fragment %3 "main" %41
>    OpDecorate %_arr_v4float_uint_1 ArrayStride 16
>    OpDecorate %_struct_37 Block
>    OpMemberDecorate %_struct_37 0 Offset 0
>    OpDecorate %39 DescriptorSet 0
>    OpDecorate %39 Binding 0
>    OpDecorate %41 Location 0
>    %void = OpTypeVoid
>    %2 = OpTypeFunction %void
>    %float = OpTypeFloat 32
>    %v4float = OpTypeVector %float 4
>    %float_0x1_36pn141 = OpConstant %float 0x1.36p-141
>    %float_0x1pn148 = OpConstant %float 0x1p-148
>    %float_76 = OpConstant %float 76
>    %float_0 = OpConstant %float 0
>    %11 = OpConstantComposite %v4float %float_0x1_36pn141 %float_0x1pn148 %float_76 %float_0
>    %float_0x1_bcpn143 = OpConstant %float 0x1.bcp-143
>    %float_0x1_cpn147 = OpConstant %float 0x1.cp-147
>    %float_83_5 = OpConstant %float 83.5
>    %15 = OpConstantComposite %v4float %float_0x1_bcpn143 %float_0x1_cpn147 %float_83_5 %float_0
>    %float_0x1_a8pn142 = OpConstant %float 0x1.a8p-142
>    %float_0x1p_128 = OpConstant %float 0x1p+128
>    %float_0_5 = OpConstant %float 0.5
>    %19 = OpConstantComposite %v4float %float_0x1_a8pn142 %float_0x1p_128 %float_0_5 %float_0
>    %float_n0x1_fffbfep_128 = OpConstant %float -0x1.fffbfep+128
>    %float_n0x1p_128 = OpConstant %float -0x1p+128
>    %float_0_75 = OpConstant %float 0.75
>    %23 = OpConstantComposite %v4float %float_n0x1_fffbfep_128 %float_n0x1p_128 %float_0_75 %float_0
>    %float_n0x1_fffd84p_128 = OpConstant %float -0x1.fffd84p+128
>    %float_0x1_8p_128 = OpConstant %float 0x1.8p+128
>    %float_n0_5 = OpConstant %float -0.5
>    %27 = OpConstantComposite %v4float %float_n0x1_fffd84p_128 %float_0x1_8p_128 %float_n0_5 %float_0
>    %28 = OpConstantComposite %v4float %float_0 %float_0 %float_0 %float_0
>    %uint = OpTypeInt 32 0
>    %uint_6 = OpConstant %uint 6
>    %_arr_v4float_uint_6 = OpTypeArray %v4float %uint_6
>    %32 = OpConstantComposite %_arr_v4float_uint_6 %11 %15 %19 %23 %27 %28
>    %_ptr_Private__arr_v4float_uint_6 = OpTypePointer Private %_arr_v4float_uint_6
>    %34 = OpVariable %_ptr_Private__arr_v4float_uint_6 Private %32
>    %uint_1 = OpConstant %uint 1
>    %_arr_v4float_uint_1 = OpTypeArray %v4float %uint_1
>    %_struct_37 = OpTypeStruct %_arr_v4float_uint_1
>    %_ptr_Uniform__struct_37 = OpTypePointer Uniform %_struct_37
>    %39 = OpVariable %_ptr_Uniform__struct_37 Uniform
>    %_ptr_Output_v4float = OpTypePointer Output %v4float
>    %41 = OpVariable %_ptr_Output_v4float Output
>    %_ptr_Function_v4float = OpTypePointer Function %v4float
>    %float_1 = OpConstant %float 1
>    %_ptr_Output_float = OpTypePointer Output %float
>    %uint_3 = OpConstant %uint 3
>    %uint_0 = OpConstant %uint 0
>    %_ptr_Uniform_v4float = OpTypePointer Uniform %v4float
>    %_ptr_Uniform_float = OpTypePointer Uniform %float
>    %_ptr_Function_float = OpTypePointer Function %float
>    %int = OpTypeInt 32 1
>    %_ptr_Private_v4float = OpTypePointer Private %v4float
>    %_ptr_Private_float = OpTypePointer Private %float
>    %uint_2 = OpConstant %uint 2
>    %3 = OpFunction %void None %2
>    %4 = OpLabel
>    %47 = OpInBoundsAccessChain %_ptr_Output_float %41 %uint_3
>    OpStore %47 %float_1
>    %50 = OpAccessChain %_ptr_Uniform_v4float %39 %uint_0 %uint_0
>    %52 = OpInBoundsAccessChain %_ptr_Uniform_float %50 %uint_0
>    %53 = OpLoad %float %52
>    %59 = OpBitcast %int %53
>    %61 = OpAccessChain %_ptr_Private_v4float %34 %59
>    %63 = OpInBoundsAccessChain %_ptr_Private_float %61 %uint_1
>    %64 = OpLoad %float %63
>    %65 = OpBitcast %uint %64
>    %66 = OpConvertUToF %float %65
>    %67 = OpInBoundsAccessChain %_ptr_Output_float %41 %uint_1
>    OpStore %67 %66
>    %70 = OpBitcast %int %53
>    %71 = OpAccessChain %_ptr_Private_v4float %34 %70
>    %72 = OpInBoundsAccessChain %_ptr_Private_float %71 %uint_0
>    %73 = OpLoad %float %72
>    %74 = OpBitcast %int %73
>    %75 = OpConvertSToF %float %74
>    %76 = OpInBoundsAccessChain %_ptr_Output_float %41 %uint_0
>    OpStore %76 %75
>    %79 = OpBitcast %int %53
>    %80 = OpAccessChain %_ptr_Private_v4float %34 %79
>    %82 = OpInBoundsAccessChain %_ptr_Private_float %80 %uint_2
>    %83 = OpLoad %float %82
>    %84 = OpInBoundsAccessChain %_ptr_Output_float %41 %uint_2
>    OpStore %84 %83
>    OpReturn
>    OpFunctionEnd
>#endif
>    0x07230203, 0x00010000, 0x00000000, 0x00000055, 0x00000000, 0x00020011, 0x00000001, 0x0003000e,
>    0x00000000, 0x00000001, 0x0006000f, 0x00000004, 0x00000003, 0x6e69616d, 0x00000000, 0x00000029,
>    0x00040047, 0x00000024, 0x00000006, 0x00000010, 0x00030047, 0x00000025, 0x00000002, 0x00050048,
>    0x00000025, 0x00000000, 0x00000023, 0x00000000, 0x00040047, 0x00000027, 0x00000022, 0x00000000,
>    0x00040047, 0x00000027, 0x00000021, 0x00000000, 0x00040047, 0x00000029, 0x0000001e, 0x00000000,
>    0x00020013, 0x00000001, 0x00030021, 0x00000002, 0x00000001, 0x00030016, 0x00000005, 0x00000020,
>    0x00040017, 0x00000006, 0x00000005, 0x00000004, 0x0004002b, 0x00000005, 0x00000007, 0x00000136,
>    0x0004002b, 0x00000005, 0x00000008, 0x00000002, 0x0004002b, 0x00000005, 0x00000009, 0x42980000,
>    0x0004002b, 0x00000005, 0x0000000a, 0x00000000, 0x0007002c, 0x00000006, 0x0000000b, 0x00000007,
>    0x00000008, 0x00000009, 0x0000000a, 0x0004002b, 0x00000005, 0x0000000c, 0x0000006f, 0x0004002b,
>    0x00000005, 0x0000000d, 0x00000007, 0x0004002b, 0x00000005, 0x0000000e, 0x42a70000, 0x0007002c,
>    0x00000006, 0x0000000f, 0x0000000c, 0x0000000d, 0x0000000e, 0x0000000a, 0x0004002b, 0x00000005,
>    0x00000010, 0x000000d4, 0x0004002b, 0x00000005, 0x00000011, 0x7f800000, 0x0004002b, 0x00000005,
>    0x00000012, 0x3f000000, 0x0007002c, 0x00000006, 0x00000013, 0x00000010, 0x00000011, 0x00000012,
>    0x0000000a, 0x0004002b, 0x00000005, 0x00000014, 0xfffffdff, 0x0004002b, 0x00000005, 0x00000015,
>    0xff800000, 0x0004002b, 0x00000005, 0x00000016, 0x3f400000, 0x0007002c, 0x00000006, 0x00000017,
>    0x00000014, 0x00000015, 0x00000016, 0x0000000a, 0x0004002b, 0x00000005, 0x00000018, 0xfffffec2,
>    0x0004002b, 0x00000005, 0x00000019, 0x7fc00000, 0x0004002b, 0x00000005, 0x0000001a, 0xbf000000,
>    0x0007002c, 0x00000006, 0x0000001b, 0x00000018, 0x00000019, 0x0000001a, 0x0000000a, 0x0007002c,
>    0x00000006, 0x0000001c, 0x0000000a, 0x0000000a, 0x0000000a, 0x0000000a, 0x00040015, 0x0000001d,
>    0x00000020, 0x00000000, 0x0004002b, 0x0000001d, 0x0000001e, 0x00000006, 0x0004001c, 0x0000001f,
>    0x00000006, 0x0000001e, 0x0009002c, 0x0000001f, 0x00000020, 0x0000000b, 0x0000000f, 0x00000013,
>    0x00000017, 0x0000001b, 0x0000001c, 0x00040020, 0x00000021, 0x00000006, 0x0000001f, 0x0005003b,
>    0x00000021, 0x00000022, 0x00000006, 0x00000020, 0x0004002b, 0x0000001d, 0x00000023, 0x00000001,
>    0x0004001c, 0x00000024, 0x00000006, 0x00000023, 0x0003001e, 0x00000025, 0x00000024, 0x00040020,
>    0x00000026, 0x00000002, 0x00000025, 0x0004003b, 0x00000026, 0x00000027, 0x00000002, 0x00040020,
>    0x00000028, 0x00000003, 0x00000006, 0x0004003b, 0x00000028, 0x00000029, 0x00000003, 0x00040020,
>    0x0000002a, 0x00000007, 0x00000006, 0x0004002b, 0x00000005, 0x0000002c, 0x3f800000, 0x00040020,
>    0x0000002d, 0x00000003, 0x00000005, 0x0004002b, 0x0000001d, 0x0000002e, 0x00000003, 0x0004002b,
>    0x0000001d, 0x00000030, 0x00000000, 0x00040020, 0x00000031, 0x00000002, 0x00000006, 0x00040020,
>    0x00000033, 0x00000002, 0x00000005, 0x00040020, 0x00000036, 0x00000007, 0x00000005, 0x00040015,
>    0x0000003a, 0x00000020, 0x00000001, 0x00040020, 0x0000003c, 0x00000006, 0x00000006, 0x00040020,
>    0x0000003e, 0x00000006, 0x00000005, 0x0004002b, 0x0000001d, 0x00000051, 0x00000002, 0x00050036,
>    0x00000001, 0x00000003, 0x00000000, 0x00000002, 0x000200f8, 0x00000004, 0x00050042, 0x0000002d,
>    0x0000002f, 0x00000029, 0x0000002e, 0x0003003e, 0x0000002f, 0x0000002c, 0x00060041, 0x00000031,
>    0x00000032, 0x00000027, 0x00000030, 0x00000030, 0x00050042, 0x00000033, 0x00000034, 0x00000032,
>    0x00000030, 0x0004003d, 0x00000005, 0x00000035, 0x00000034, 0x0004007c, 0x0000003a, 0x0000003b,
>    0x00000035, 0x00050041, 0x0000003c, 0x0000003d, 0x00000022, 0x0000003b, 0x00050042, 0x0000003e,
>    0x0000003f, 0x0000003d, 0x00000023, 0x0004003d, 0x00000005, 0x00000040, 0x0000003f, 0x0004007c,
>    0x0000001d, 0x00000041, 0x00000040, 0x00040070, 0x00000005, 0x00000042, 0x00000041, 0x00050042,
>    0x0000002d, 0x00000043, 0x00000029, 0x00000023, 0x0003003e, 0x00000043, 0x00000042, 0x0004007c,
>    0x0000003a, 0x00000046, 0x00000035, 0x00050041, 0x0000003c, 0x00000047, 0x00000022, 0x00000046,
>    0x00050042, 0x0000003e, 0x00000048, 0x00000047, 0x00000030, 0x0004003d, 0x00000005, 0x00000049,
>    0x00000048, 0x0004007c, 0x0000003a, 0x0000004a, 0x00000049, 0x0004006f, 0x00000005, 0x0000004b,
>    0x0000004a, 0x00050042, 0x0000002d, 0x0000004c, 0x00000029, 0x00000030, 0x0003003e, 0x0000004c,
>    0x0000004b, 0x0004007c, 0x0000003a, 0x0000004f, 0x00000035, 0x00050041, 0x0000003c, 0x00000050,
>    0x00000022, 0x0000004f, 0x00050042, 0x0000003e, 0x00000052, 0x00000050, 0x00000051, 0x0004003d,
>    0x00000005, 0x00000053, 0x00000052, 0x00050042, 0x0000002d, 0x00000054, 0x00000029, 0x00000051,
>    0x0003003e, 0x00000054, 0x00000053, 0x000100fd, 0x00010038,
>};
>
>static uint32_t check_uint32(uint32_t value, uint32_t expected_value)
>{
>    if (value != expected_value)
>        printf("Got value %u, expected %u.\n", value, expected_value);
>}
>
>int main(void)
>{
>    VkPhysicalDevice physical_device;
>    VkDescriptorSetLayout set_layout;
>    VkRenderPass render_pass;
>    VkPipelineLayout layout;
>    VkShaderModule vs, fs;
>    VkInstance instance;
>    VkPipeline pipeline;
>    VkDescriptorSet set;
>    unsigned int x, y;
>    VkDevice device;
>    VkQueue queue;
>
>    instance = create_instance();
>    assert(instance != VK_NULL_HANDLE);
>    physical_device = select_physical_device(instance);
>    assert(physical_device != VK_NULL_HANDLE);
>    device = create_device(instance, physical_device);
>    assert(device != VK_NULL_HANDLE);
>
>    vs = create_shader_module(device, sizeof(vs_code), &vs_code);
>    assert(vs != VK_NULL_HANDLE);
>    fs = create_shader_module(device, sizeof(fs_code), &fs_code);
>    assert(vs != VK_NULL_HANDLE);
>
>    set_layout = create_descriptor_set_layout(device);
>    assert(set_layout != VK_NULL_HANDLE);
>
>    layout = create_pipeline_layout(device, set_layout);
>    assert(layout != VK_NULL_HANDLE);
>    render_pass = create_render_pass(device);
>    assert(render_pass != VK_NULL_HANDLE);
>
>    pipeline = create_graphics_pipeline(device, layout, vs, fs, render_pass);
>    assert(pipeline != VK_NULL_HANDLE);
>
>    vkDestroyShaderModule(device, vs, NULL);
>    vkDestroyShaderModule(device, fs, NULL);
>    vkDestroyPipeline(device, pipeline, NULL);
>    vkDestroyRenderPass(device, render_pass, NULL);
>    vkDestroyPipelineLayout(device, layout, NULL);
>    vkDestroyDescriptorSetLayout(device, set_layout, NULL);
>
>    vkDestroyDevice(device, NULL);
>    vkDestroyInstance(instance, NULL);
>    return 0;
>}

Actions: View

Attachments on bug 103241: 141010

Use of freedesktop.org services, including Bugzilla, is subject to our Code of Conduct. How we collect and use information is described in our Privacy Policy.