Use UNIMPLEMENTED() for missing functionality we claim support for

src/Device/Blitter.cpp

@@ -1750,7 +1750,7 @@ void Blitter::blit(const vk::Image *src, vk::Image *dst, VkImageBlit region, VkF
 	if((region.srcSubresource.layerCount != region.dstSubresource.layerCount) ||
 	   (region.srcSubresource.aspectMask != region.dstSubresource.aspectMask))
 	{
-		UNSUPPORTED("region");
+		UNIMPLEMENTED("region");
 	}
 
 	if(region.dstOffsets[0].x > region.dstOffsets[1].x)
@@ -1892,7 +1892,7 @@ Blitter::CornerUpdateRoutineType Blitter::generateCornerUpdate(const State &stat
 
 	if(state.srcSamples != 1)
 	{
-		UNSUPPORTED("state.srcSamples %d", state.srcSamples);
+		UNIMPLEMENTED("state.srcSamples %d", state.srcSamples);
 	}
 
 	CornerUpdateFunction function;
@@ -1924,8 +1924,8 @@ void Blitter::updateBorders(vk::Image *image, const VkImageSubresourceLayers &su
 {
 	if(image->getArrayLayers() < (subresourceLayers.baseArrayLayer + 6))
 	{
-		UNSUPPORTED("image->getArrayLayers() %d, baseArrayLayer %d",
-		            image->getArrayLayers(), subresourceLayers.baseArrayLayer);
+		UNIMPLEMENTED("image->getArrayLayers() %d, baseArrayLayer %d",
+		              image->getArrayLayers(), subresourceLayers.baseArrayLayer);
 	}
 
 	// From Vulkan 1.1 spec, section 11.5. Image Views:
@@ -1982,7 +1982,7 @@ void Blitter::updateBorders(vk::Image *image, const VkImageSubresourceLayers &su
 
 	if(samples != VK_SAMPLE_COUNT_1_BIT)
 	{
-		UNSUPPORTED("Multi-sampled cube: %d samples", static_cast<int>(samples));
+		UNIMPLEMENTED("Multi-sampled cube: %d samples", static_cast<int>(samples));
 	}
 
 	auto cornerUpdateRoutine = getCornerUpdateRoutine(state);

src/Pipeline/SpirvShader.cpp

@@ -272,7 +272,7 @@ SpirvShader::SpirvShader(
 					}
 					case spv::StorageClassAtomicCounter:
 					case spv::StorageClassImage:
-						UNSUPPORTED("StorageClass %d not yet implemented", (int)storageClass);
+						UNSUPPORTED("StorageClass %d not yet supported", (int)storageClass);
 						break;
 
 					case spv::StorageClassCrossWorkgroup:

src/Pipeline/SpirvShaderControlFlow.cpp

@@ -581,14 +581,16 @@ SpirvShader::EmitResult SpirvShader::EmitFunctionCall(InsnIterator insn, EmitSta
 		{
 			if(insnNumber > 1)
 			{
-				UNSUPPORTED("Function block number of instructions: %d", insnNumber);
+				UNIMPLEMENTED("Function block number of instructions: %d", insnNumber);
 				return EmitResult::Continue;
 			}
+
 			if(blockInsn.opcode() != wrapOpKill[insnNumber++])
 			{
-				UNSUPPORTED("Function block instruction %d : %s", insnNumber - 1, OpcodeName(blockInsn.opcode()).c_str());
+				UNIMPLEMENTED("Function block instruction %d : %s", insnNumber - 1, OpcodeName(blockInsn.opcode()).c_str());
 				return EmitResult::Continue;
 			}
+
 			if(blockInsn.opcode() == spv::OpKill)
 			{
 				EmitInstruction(blockInsn, state);

src/Pipeline/SpirvShaderMemory.cpp

@@ -225,8 +225,9 @@ SpirvShader::EmitResult SpirvShader::EmitVariable(InsnIterator insn, EmitState *
 		Object::ID initializerId = insn.word(4);
 		if(getObject(initializerId).kind != Object::Kind::Constant)
 		{
-			UNSUPPORTED("Non-constant initializers not yet implemented");
+			UNIMPLEMENTED("Non-constant initializers not yet implemented");
 		}
+
 		switch(objectTy.storageClass)
 		{
 			case spv::StorageClassOutput:

src/Vulkan/VkCommandBuffer.cpp

@@ -547,26 +547,30 @@ public:
 			context.depthBias = executionState.dynamicState.depthBiasConstantFactor;
 			context.slopeDepthBias = executionState.dynamicState.depthBiasSlopeFactor;
 		}
+
 		if(pipeline->hasDynamicState(VK_DYNAMIC_STATE_DEPTH_BOUNDS) && context.depthBoundsTestEnable)
 		{
-			// Unless the VK_EXT_depth_range_unrestricted extension is enabled minDepthBounds and maxDepthBounds must be between 0.0 and 1.0, inclusive
+			// Unless the VK_EXT_depth_range_unrestricted extension is enabled, minDepthBounds and maxDepthBounds must be between 0.0 and 1.0, inclusive
 			ASSERT(executionState.dynamicState.minDepthBounds >= 0.0f &&
 			       executionState.dynamicState.minDepthBounds <= 1.0f);
 			ASSERT(executionState.dynamicState.maxDepthBounds >= 0.0f &&
 			       executionState.dynamicState.maxDepthBounds <= 1.0f);
 
-			UNSUPPORTED("depthBoundsTestEnable");
+			UNSUPPORTED("VkPhysicalDeviceFeatures::depthBounds");
 		}
+
 		if(pipeline->hasDynamicState(VK_DYNAMIC_STATE_STENCIL_COMPARE_MASK) && context.stencilEnable)
 		{
 			context.frontStencil.compareMask = executionState.dynamicState.compareMask[0];
 			context.backStencil.compareMask = executionState.dynamicState.compareMask[1];
 		}
+
 		if(pipeline->hasDynamicState(VK_DYNAMIC_STATE_STENCIL_WRITE_MASK) && context.stencilEnable)
 		{
 			context.frontStencil.writeMask = executionState.dynamicState.writeMask[0];
 			context.backStencil.writeMask = executionState.dynamicState.writeMask[1];
 		}
+
 		if(pipeline->hasDynamicState(VK_DYNAMIC_STATE_STENCIL_REFERENCE) && context.stencilEnable)
 		{
 			context.frontStencil.reference = executionState.dynamicState.reference[0];
@@ -593,7 +597,7 @@ public:
 						processPrimitiveRestart(static_cast<uint32_t *>(indexBuffer), count, pipeline, indexBuffers);
 						break;
 					default:
-						UNSUPPORTED("executionState.indexType %d", int(executionState.indexType));
+						UNSUPPORTED("VkIndexType %d", int(executionState.indexType));
 				}
 			}
 			else
@@ -1319,6 +1323,17 @@ VkResult CommandBuffer::begin(VkCommandBufferUsageFlags flags, const VkCommandBu
 
 	// pInheritanceInfo merely contains optimization hints, so we currently ignore it
 
+	// "pInheritanceInfo is a pointer to a VkCommandBufferInheritanceInfo structure, used if commandBuffer is a
+	//  secondary command buffer. If this is a primary command buffer, then this value is ignored."
+	if(level == VK_COMMAND_BUFFER_LEVEL_SECONDARY)
+	{
+		if(pInheritanceInfo->queryFlags != 0)
+		{
+			// "If the inherited queries feature is not enabled, queryFlags must be 0"
+			UNSUPPORTED("VkPhysicalDeviceFeatures::inheritedQueries");
+		}
+	}
+
 	if(state != INITIAL)
 	{
 		// Implicit reset
@@ -1427,7 +1442,7 @@ void CommandBuffer::bindPipeline(VkPipelineBindPoint pipelineBindPoint, Pipeline
 			addCommand<::CmdPipelineBind>(pipelineBindPoint, pipeline);
 			break;
 		default:
-			UNSUPPORTED("pipelineBindPoint");
+			UNSUPPORTED("VkPipelineBindPoint %d", int(pipelineBindPoint));
 	}
 }
 
@@ -1476,7 +1491,7 @@ void CommandBuffer::setViewport(uint32_t firstViewport, uint32_t viewportCount,
 {
 	if(firstViewport != 0 || viewportCount > 1)
 	{
-		UNSUPPORTED("viewport");
+		UNSUPPORTED("VkPhysicalDeviceFeatures::multiViewport");
 	}
 
 	for(uint32_t i = 0; i < viewportCount; i++)
@@ -1489,7 +1504,7 @@ void CommandBuffer::setScissor(uint32_t firstScissor, uint32_t scissorCount, con
 {
 	if(firstScissor != 0 || scissorCount > 1)
 	{
-		UNSUPPORTED("scissor");
+		UNSUPPORTED("VkPhysicalDeviceFeatures::multiViewport");
 	}
 
 	for(uint32_t i = 0; i < scissorCount; i++)

src/Vulkan/VkDevice.cpp

@@ -93,7 +93,7 @@ Device::Device(const VkDeviceCreateInfo *pCreateInfo, void *mem, PhysicalDevice
 	if(pCreateInfo->enabledLayerCount)
 	{
 		// "The ppEnabledLayerNames and enabledLayerCount members of VkDeviceCreateInfo are deprecated and their values must be ignored by implementations."
-		UNSUPPORTED("enabledLayerCount");  // TODO(b/119321052): UNSUPPORTED() should be used only for features that must still be implemented. Use a more informational macro here.
+		UNSUPPORTED("enabledLayerCount");
 	}
 
 	// FIXME (b/119409619): use an allocator here so we can control all memory allocations

src/Vulkan/VkDeviceMemoryExternalAndroid.hpp

@@ -55,7 +55,7 @@ public:
 
 						if(exportInfo->handleTypes != VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID)
 						{
-							UNSUPPORTED("exportInfo->handleTypes");
+							UNIMPLEMENTED("exportInfo->handleTypes");
 						}
 						exportAhb = true;
 					}
@@ -146,7 +146,7 @@ public:
 
 	static VkResult getAhbProperties(const struct AHardwareBuffer *buffer, VkAndroidHardwareBufferPropertiesANDROID *pProperties)
 	{
-		UNSUPPORTED("getAhbProperties");
+		UNIMPLEMENTED("getAhbProperties");
 		return VK_SUCCESS;
 	}
 

src/Vulkan/VkDeviceMemoryExternalLinux.hpp

@@ -47,7 +47,7 @@ public:
 
 						if(importInfo->handleType != VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT)
 						{
-							UNSUPPORTED("importInfo->handleType");
+							UNIMPLEMENTED("importInfo->handleType");
 						}
 						importFd = true;
 						fd = importInfo->fd;
@@ -59,7 +59,7 @@ public:
 
 						if(exportInfo->handleTypes != VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT)
 						{
-							UNSUPPORTED("exportInfo->handleTypes");
+							UNIMPLEMENTED("exportInfo->handleTypes");
 						}
 						exportFd = true;
 					}

src/Vulkan/VkImage.cpp

@@ -894,7 +894,7 @@ void Image::clear(const VkClearColorValue &color, const VkImageSubresourceRange
 {
 	if(!(subresourceRange.aspectMask == VK_IMAGE_ASPECT_COLOR_BIT))
 	{
-		UNSUPPORTED("aspectMask");
+		UNIMPLEMENTED("aspectMask");
 	}
 
 	device->getBlitter()->clear((void *)color.float32, getClearFormat(), this, format, subresourceRange);
@@ -905,7 +905,7 @@ void Image::clear(const VkClearDepthStencilValue &color, const VkImageSubresourc
 	if((subresourceRange.aspectMask & ~(VK_IMAGE_ASPECT_DEPTH_BIT |
 	                                    VK_IMAGE_ASPECT_STENCIL_BIT)) != 0)
 	{
-		UNSUPPORTED("aspectMask");
+		UNIMPLEMENTED("aspectMask");
 	}
 
 	if(subresourceRange.aspectMask & VK_IMAGE_ASPECT_DEPTH_BIT)
@@ -929,7 +929,7 @@ void Image::clear(const VkClearValue &clearValue, const vk::Format &viewFormat,
 	     (subresourceRange.aspectMask & (VK_IMAGE_ASPECT_DEPTH_BIT |
 	                                     VK_IMAGE_ASPECT_STENCIL_BIT))))
 	{
-		UNSUPPORTED("subresourceRange");
+		UNIMPLEMENTED("subresourceRange");
 	}
 
 	if(subresourceRange.aspectMask == VK_IMAGE_ASPECT_COLOR_BIT)

src/Vulkan/VkImageView.cpp

@@ -120,12 +120,12 @@ void ImageView::clear(const VkClearValue &clearValue, const VkImageAspectFlags a
 
 	if(!imageTypesMatch(image->getImageType()))
 	{
-		UNSUPPORTED("imageTypesMatch");
+		UNIMPLEMENTED("imageTypesMatch");
 	}
 
 	if(!format.isCompatible(image->getFormat()))
 	{
-		UNSUPPORTED("incompatible formats");
+		UNIMPLEMENTED("incompatible formats");
 	}
 
 	VkImageSubresourceRange sr = subresourceRange;
@@ -139,12 +139,12 @@ void ImageView::clear(const VkClearValue &clearValue, const VkImageAspectFlags a
 
 	if(!imageTypesMatch(image->getImageType()))
 	{
-		UNSUPPORTED("imageTypesMatch");
+		UNIMPLEMENTED("imageTypesMatch");
 	}
 
 	if(!format.isCompatible(image->getFormat()))
 	{
-		UNSUPPORTED("incompatible formats");
+		UNIMPLEMENTED("incompatible formats");
 	}
 
 	VkImageSubresourceRange sr;
@@ -173,7 +173,7 @@ void ImageView::resolve(ImageView *resolveAttachment, int layer)
 {
 	if((subresourceRange.levelCount != 1) || (resolveAttachment->subresourceRange.levelCount != 1))
 	{
-		UNSUPPORTED("levelCount");
+		UNIMPLEMENTED("levelCount");
 	}
 
 	VkImageCopy region;
@@ -201,7 +201,7 @@ void ImageView::resolve(ImageView *resolveAttachment)
 {
 	if((subresourceRange.levelCount != 1) || (resolveAttachment->subresourceRange.levelCount != 1))
 	{
-		UNSUPPORTED("levelCount");
+		UNIMPLEMENTED("levelCount");
 	}
 
 	VkImageCopy region;
@@ -244,7 +244,7 @@ const Image *ImageView::getImage(Usage usage) const
 		case SAMPLING:
 			return image->getSampledImage(format);
 		default:
-			UNSUPPORTED("usage %d", int(usage));
+			UNREACHABLE("usage %d", int(usage));
 			return nullptr;
 	}
 }

src/Vulkan/VkPipeline.cpp

@@ -149,17 +149,27 @@ GraphicsPipeline::GraphicsPipeline(const VkGraphicsPipelineCreateInfo *pCreateIn
 {
 	context.robustBufferAccess = robustBufferAccess;
 
-	if(((pCreateInfo->flags &
-	     ~(VK_PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT |
-	       VK_PIPELINE_CREATE_DERIVATIVE_BIT |
-	       VK_PIPELINE_CREATE_ALLOW_DERIVATIVES_BIT)) != 0) ||
-	   (pCreateInfo->pTessellationState != nullptr))
+	if((pCreateInfo->flags &
+	    ~(VK_PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT |
+	      VK_PIPELINE_CREATE_DERIVATIVE_BIT |
+	      VK_PIPELINE_CREATE_ALLOW_DERIVATIVES_BIT)) != 0)
 	{
-		UNSUPPORTED("pCreateInfo settings");
+		UNSUPPORTED("pCreateInfo->flags %d", int(pCreateInfo->flags));
+	}
+
+	if(pCreateInfo->pTessellationState != nullptr)
+	{
+		UNSUPPORTED("pCreateInfo->pTessellationState");
 	}
 
 	if(pCreateInfo->pDynamicState)
 	{
+		if(pCreateInfo->pDynamicState->flags != 0)
+		{
+			// Vulkan 1.2: "flags is reserved for future use." "flags must be 0"
+			UNSUPPORTED("pCreateInfo->pDynamicState->flags %d", int(pCreateInfo->pDynamicState->flags));
+		}
+
 		for(uint32_t i = 0; i < pCreateInfo->pDynamicState->dynamicStateCount; i++)
 		{
 			VkDynamicState dynamicState = pCreateInfo->pDynamicState->pDynamicStates[i];
@@ -178,14 +188,16 @@ GraphicsPipeline::GraphicsPipeline(const VkGraphicsPipelineCreateInfo *pCreateIn
 					dynamicStateFlags |= (1 << dynamicState);
 					break;
 				default:
-					UNSUPPORTED("dynamic state");
+					UNSUPPORTED("VkDynamicState %d", int(dynamicState));
 			}
 		}
 	}
 
 	const VkPipelineVertexInputStateCreateInfo *vertexInputState = pCreateInfo->pVertexInputState;
+
 	if(vertexInputState->flags != 0)
 	{
+		// Vulkan 1.2: "flags is reserved for future use." "flags must be 0"
 		UNSUPPORTED("vertexInputState->flags");
 	}
 
@@ -214,23 +226,30 @@ GraphicsPipeline::GraphicsPipeline(const VkGraphicsPipelineCreateInfo *pCreateIn
 		input.instanceStride = instanceStrides[desc.binding];
 	}
 
-	const VkPipelineInputAssemblyStateCreateInfo *assemblyState = pCreateInfo->pInputAssemblyState;
-	if(assemblyState->flags != 0)
+	const VkPipelineInputAssemblyStateCreateInfo *inputAssemblyState = pCreateInfo->pInputAssemblyState;
+
+	if(inputAssemblyState->flags != 0)
 	{
-		UNSUPPORTED("pCreateInfo->pInputAssemblyState settings");
+		// Vulkan 1.2: "flags is reserved for future use." "flags must be 0"
+		UNSUPPORTED("pCreateInfo->pInputAssemblyState->flags %d", int(pCreateInfo->pInputAssemblyState->flags));
 	}
 
-	primitiveRestartEnable = (assemblyState->primitiveRestartEnable != VK_FALSE);
-	context.topology = assemblyState->topology;
+	primitiveRestartEnable = (inputAssemblyState->primitiveRestartEnable != VK_FALSE);
+	context.topology = inputAssemblyState->topology;
 
 	const VkPipelineViewportStateCreateInfo *viewportState = pCreateInfo->pViewportState;
 	if(viewportState)
 	{
-		if((viewportState->flags != 0) ||
-		   (viewportState->viewportCount != 1) ||
+		if(viewportState->flags != 0)
+		{
+			// Vulkan 1.2: "flags is reserved for future use." "flags must be 0"
+			UNSUPPORTED("pCreateInfo->pViewportState->flags %d", int(pCreateInfo->pViewportState->flags));
+		}
+
+		if((viewportState->viewportCount != 1) ||
 		   (viewportState->scissorCount != 1))
 		{
-			UNSUPPORTED("pCreateInfo->pViewportState settings");
+			UNSUPPORTED("VkPhysicalDeviceFeatures::multiViewport");
 		}
 
 		if(!hasDynamicState(VK_DYNAMIC_STATE_SCISSOR))
@@ -245,10 +264,16 @@ GraphicsPipeline::GraphicsPipeline(const VkGraphicsPipelineCreateInfo *pCreateIn
 	}
 
 	const VkPipelineRasterizationStateCreateInfo *rasterizationState = pCreateInfo->pRasterizationState;
-	if((rasterizationState->flags != 0) ||
-	   (rasterizationState->depthClampEnable != VK_FALSE))
+
+	if(rasterizationState->flags != 0)
+	{
+		// Vulkan 1.2: "flags is reserved for future use." "flags must be 0"
+		UNSUPPORTED("pCreateInfo->pRasterizationState->flags %d", int(pCreateInfo->pRasterizationState->flags));
+	}
+
+	if(rasterizationState->depthClampEnable != VK_FALSE)
 	{
-		UNSUPPORTED("pCreateInfo->pRasterizationState settings");
+		UNSUPPORTED("VkPhysicalDeviceFeatures::depthClamp");
 	}
 
 	context.rasterizerDiscard = (rasterizationState->rasterizerDiscardEnable != VK_FALSE);
@@ -290,6 +315,22 @@ GraphicsPipeline::GraphicsPipeline(const VkGraphicsPipelineCreateInfo *pCreateIn
 	const VkPipelineMultisampleStateCreateInfo *multisampleState = pCreateInfo->pMultisampleState;
 	if(multisampleState)
 	{
+		if(multisampleState->flags != 0)
+		{
+			// Vulkan 1.2: "flags is reserved for future use." "flags must be 0"
+			UNSUPPORTED("pCreateInfo->pMultisampleState->flags %d", int(pCreateInfo->pMultisampleState->flags));
+		}
+
+		if(multisampleState->sampleShadingEnable != VK_FALSE)
+		{
+			UNSUPPORTED("VkPhysicalDeviceFeatures::sampleRateShading");
+		}
+
+		if(multisampleState->alphaToOneEnable != VK_FALSE)
+		{
+			UNSUPPORTED("VkPhysicalDeviceFeatures::alphaToOne");
+		}
+
 		switch(multisampleState->rasterizationSamples)
 		{
 			case VK_SAMPLE_COUNT_1_BIT:
@@ -308,13 +349,6 @@ GraphicsPipeline::GraphicsPipeline(const VkGraphicsPipelineCreateInfo *pCreateIn
 		}
 
 		context.alphaToCoverage = (multisampleState->alphaToCoverageEnable != VK_FALSE);
-
-		if((multisampleState->flags != 0) ||
-		   (multisampleState->sampleShadingEnable != VK_FALSE) ||
-		   (multisampleState->alphaToOneEnable != VK_FALSE))
-		{
-			UNSUPPORTED("multisampleState");
-		}
 	}
 	else
 	{
@@ -324,10 +358,15 @@ GraphicsPipeline::GraphicsPipeline(const VkGraphicsPipelineCreateInfo *pCreateIn
 	const VkPipelineDepthStencilStateCreateInfo *depthStencilState = pCreateInfo->pDepthStencilState;
 	if(depthStencilState)
 	{
-		if((depthStencilState->flags != 0) ||
-		   (depthStencilState->depthBoundsTestEnable != VK_FALSE))
+		if(depthStencilState->flags != 0)
+		{
+			// Vulkan 1.2: "flags is reserved for future use." "flags must be 0"
+			UNSUPPORTED("pCreateInfo->pDepthStencilState->flags %d", int(pCreateInfo->pDepthStencilState->flags));
+		}
+
+		if(depthStencilState->depthBoundsTestEnable != VK_FALSE)
 		{
-			UNSUPPORTED("depthStencilState");
+			UNSUPPORTED("VkPhysicalDeviceFeatures::depthBounds");
 		}
 
 		context.depthBoundsTestEnable = (depthStencilState->depthBoundsTestEnable != VK_FALSE);
@@ -346,10 +385,15 @@ GraphicsPipeline::GraphicsPipeline(const VkGraphicsPipelineCreateInfo *pCreateIn
 	const VkPipelineColorBlendStateCreateInfo *colorBlendState = pCreateInfo->pColorBlendState;
 	if(colorBlendState)
 	{
-		if((colorBlendState->flags != 0) ||
-		   ((colorBlendState->logicOpEnable != VK_FALSE)))
+		if(pCreateInfo->pColorBlendState->flags != 0)
+		{
+			// Vulkan 1.2: "flags is reserved for future use." "flags must be 0"
+			UNSUPPORTED("pCreateInfo->pColorBlendState->flags %d", int(pCreateInfo->pColorBlendState->flags));
+		}
+
+		if(colorBlendState->logicOpEnable != VK_FALSE)
 		{
-			UNSUPPORTED("colorBlendState");
+			UNSUPPORTED("VkPhysicalDeviceFeatures::logicOp");
 		}
 
 		if(!hasDynamicState(VK_DYNAMIC_STATE_BLEND_CONSTANTS))
@@ -427,7 +471,8 @@ void GraphicsPipeline::compileShaders(const VkAllocationCallbacks *pAllocator, c
 	{
 		if(pStage->flags != 0)
 		{
-			UNSUPPORTED("pStage->flags");
+			// Vulkan 1.2: "flags must be 0"
+			UNSUPPORTED("pStage->flags %d", int(pStage->flags));
 		}
 
 		const ShaderModule *module = vk::Cast(pStage->module);
@@ -479,7 +524,7 @@ uint32_t GraphicsPipeline::computePrimitiveCount(uint32_t vertexCount) const
 		case VK_PRIMITIVE_TOPOLOGY_TRIANGLE_FAN:
 			return std::max<uint32_t>(vertexCount, 2) - 2;
 		default:
-			UNSUPPORTED("context.topology %d", int(context.topology));
+			UNSUPPORTED("VkPrimitiveTopology %d", int(context.topology));
 	}
 
 	return 0;

src/Vulkan/VkQueryPool.cpp

@@ -92,7 +92,7 @@ QueryPool::QueryPool(const VkQueryPoolCreateInfo *pCreateInfo, void *mem)
     , type(pCreateInfo->queryType)
     , count(pCreateInfo->queryCount)
 {
-	// According to the Vulkan spec, section 34.1. Features:
+	// According to the Vulkan 1.2 spec, section 30. Features:
 	// "pipelineStatisticsQuery specifies whether the pipeline statistics
 	//  queries are supported. If this feature is not enabled, queries of
 	//  type VK_QUERY_TYPE_PIPELINE_STATISTICS cannot be created, and
@@ -100,7 +100,7 @@ QueryPool::QueryPool(const VkQueryPoolCreateInfo *pCreateInfo, void *mem)
 	//  pipelineStatistics member of the VkQueryPoolCreateInfo structure."
 	if(type == VK_QUERY_TYPE_PIPELINE_STATISTICS)
 	{
-		UNSUPPORTED("pCreateInfo->queryType");
+		UNSUPPORTED("VkPhysicalDeviceFeatures::pipelineStatisticsQuery");
 	}
 
 	// Construct all queries
@@ -189,7 +189,7 @@ void QueryPool::begin(uint32_t query, VkQueryControlFlags flags)
 
 	if(flags != 0)
 	{
-		UNSUPPORTED("flags");
+		UNIMPLEMENTED("vkCmdBeginQuery::flags %d", int(flags));
 	}
 
 	pool[query].prepare(type);

src/Vulkan/VkQueue.cpp

@@ -178,7 +178,7 @@ void Queue::taskLoop(marl::Scheduler *scheduler)
 				submitQueue(task);
 				break;
 			default:
-				UNSUPPORTED("task.type %d", static_cast<int>(task.type));
+				UNREACHABLE("task.type %d", static_cast<int>(task.type));
 				break;
 		}
 	}

src/Vulkan/VkSemaphore.cpp

@@ -56,7 +56,7 @@ struct SemaphoreCreateInfo
 				exportSemaphore = true;
 				if(exportInfo->handleTypes != Semaphore::External::kExternalSemaphoreHandleType)
 				{
-					UNSUPPORTED("exportInfo->handleTypes");
+					UNIMPLEMENTED("exportInfo->handleTypes");
 				}
 				break;
 			}