diff --git a/external/vulkancts/data/vulkan/glsl/es310/linkage.test b/external/vulkancts/data/vulkan/glsl/es310/linkage.test
index 21c62b0..d463062 100644
--- a/external/vulkancts/data/vulkan/glsl/es310/linkage.test
+++ b/external/vulkancts/data/vulkan/glsl/es310/linkage.test
@@ -4,32 +4,6 @@
 
 	# Linking rules
 	group rules "Varying linking rules"
-		# not declared in vertex shader, declared in fragment shader
-		case fragment_declare
-			version 310 es
-			desc "varying declared in fragment shader, no reference in vertex shader"
-			values { output float out0 = 1.0; }
-			vertex ""
-				#version 310 es
-				${VERTEX_DECLARATIONS}
-				void main()
-				{
-					${VERTEX_OUTPUT}
-				}
-			""
-			fragment ""
-				#version 310 es
-				precision mediump float;
-				layout(location = 0) in mediump float var;
-				${FRAGMENT_DECLARATIONS}
-				void main()
-				{
-					out0 = 1.0;
-					${FRAGMENT_OUTPUT}
-				}
-			""
-		end
-
 		# declared in vertex shader, no reference in frag shader
 		case vertex_declare
 			version 310 es
diff --git a/external/vulkancts/modules/vulkan/api/vktApiCopiesAndBlittingTests.cpp b/external/vulkancts/modules/vulkan/api/vktApiCopiesAndBlittingTests.cpp
index 961cd17..43bd8a9 100644
--- a/external/vulkancts/modules/vulkan/api/vktApiCopiesAndBlittingTests.cpp
+++ b/external/vulkancts/modules/vulkan/api/vktApiCopiesAndBlittingTests.cpp
@@ -296,7 +296,7 @@
 		VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,			// VkStructureType			sType;
 		DE_NULL,										// const void*				pNext;
 		0u,												// VkAccessFlags			srcAccessMask;
-		0u,												// VkAccessFlags			dstAccessMask;
+		VK_ACCESS_TRANSFER_WRITE_BIT,					// VkAccessFlags			dstAccessMask;
 		VK_IMAGE_LAYOUT_UNDEFINED,						// VkImageLayout			oldLayout;
 		VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,			// VkImageLayout			newLayout;
 		VK_QUEUE_FAMILY_IGNORED,						// deUint32					srcQueueFamilyIndex;
@@ -705,45 +705,46 @@
 	for (deUint32 i = 0; i < m_params.regions.size(); i++)
 		imageCopies[i] = m_params.regions[i].imageCopy;
 
-	// Barriers for copying image to buffer
-	const VkImageMemoryBarrier srcImageBarrier =
+	const VkImageMemoryBarrier imageBarriers[] =
 	{
-		VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,		// VkStructureType			sType;
-		DE_NULL,									// const void*				pNext;
-		VK_ACCESS_TRANSFER_WRITE_BIT,				// VkAccessFlags			srcAccessMask;
-		VK_ACCESS_TRANSFER_READ_BIT,				// VkAccessFlags			dstAccessMask;
-		VK_IMAGE_LAYOUT_GENERAL,					// VkImageLayout			oldLayout;
-		VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,		// VkImageLayout			newLayout;
-		VK_QUEUE_FAMILY_IGNORED,					// deUint32					srcQueueFamilyIndex;
-		VK_QUEUE_FAMILY_IGNORED,					// deUint32					dstQueueFamilyIndex;
-		m_source.get(),								// VkImage					image;
-		{											// VkImageSubresourceRange	subresourceRange;
-			getAspectFlag(srcTcuFormat),	// VkImageAspectFlags	aspectMask;
-			0u,							// deUint32				baseMipLevel;
-			1u,							// deUint32				mipLevels;
-			0u,							// deUint32				baseArraySlice;
-			1u							// deUint32				arraySize;
-		}
-	};
-
-	const VkImageMemoryBarrier dstImageBarrier =
-	{
-		VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,		// VkStructureType			sType;
-		DE_NULL,									// const void*				pNext;
-		VK_ACCESS_TRANSFER_WRITE_BIT,				// VkAccessFlags			srcAccessMask;
-		VK_ACCESS_TRANSFER_READ_BIT,				// VkAccessFlags			dstAccessMask;
-		VK_IMAGE_LAYOUT_GENERAL,					// VkImageLayout			oldLayout;
-		VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,		// VkImageLayout			newLayout;
-		VK_QUEUE_FAMILY_IGNORED,					// deUint32					srcQueueFamilyIndex;
-		VK_QUEUE_FAMILY_IGNORED,					// deUint32					dstQueueFamilyIndex;
-		m_destination.get(),						// VkImage					image;
-		{											// VkImageSubresourceRange	subresourceRange;
-			getAspectFlag(dstTcuFormat),	// VkImageAspectFlags	aspectMask;
-			0u,							// deUint32				baseMipLevel;
-			1u,							// deUint32				mipLevels;
-			0u,							// deUint32				baseArraySlice;
-			1u							// deUint32				arraySize;
-		}
+		// source image
+		{
+			VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,		// VkStructureType			sType;
+			DE_NULL,									// const void*				pNext;
+			VK_ACCESS_TRANSFER_WRITE_BIT,				// VkAccessFlags			srcAccessMask;
+			VK_ACCESS_TRANSFER_READ_BIT,				// VkAccessFlags			dstAccessMask;
+			VK_IMAGE_LAYOUT_GENERAL,					// VkImageLayout			oldLayout;
+			VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,		// VkImageLayout			newLayout;
+			VK_QUEUE_FAMILY_IGNORED,					// deUint32					srcQueueFamilyIndex;
+			VK_QUEUE_FAMILY_IGNORED,					// deUint32					dstQueueFamilyIndex;
+			m_source.get(),								// VkImage					image;
+			{											// VkImageSubresourceRange	subresourceRange;
+				getAspectFlag(srcTcuFormat),	// VkImageAspectFlags	aspectMask;
+				0u,								// deUint32				baseMipLevel;
+				1u,								// deUint32				mipLevels;
+				0u,								// deUint32				baseArraySlice;
+				1u								// deUint32				arraySize;
+			}
+		},
+		// destination image
+		{
+			VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,		// VkStructureType			sType;
+			DE_NULL,									// const void*				pNext;
+			VK_ACCESS_TRANSFER_WRITE_BIT,				// VkAccessFlags			srcAccessMask;
+			VK_ACCESS_TRANSFER_WRITE_BIT,				// VkAccessFlags			dstAccessMask;
+			VK_IMAGE_LAYOUT_GENERAL,					// VkImageLayout			oldLayout;
+			VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,		// VkImageLayout			newLayout;
+			VK_QUEUE_FAMILY_IGNORED,					// deUint32					srcQueueFamilyIndex;
+			VK_QUEUE_FAMILY_IGNORED,					// deUint32					dstQueueFamilyIndex;
+			m_destination.get(),						// VkImage					image;
+			{											// VkImageSubresourceRange	subresourceRange;
+				getAspectFlag(dstTcuFormat),	// VkImageAspectFlags	aspectMask;
+				0u,								// deUint32				baseMipLevel;
+				1u,								// deUint32				mipLevels;
+				0u,								// deUint32				baseArraySlice;
+				1u								// deUint32				arraySize;
+			}
+		},
 	};
 
 	const VkCommandBufferBeginInfo cmdBufferBeginInfo =
@@ -755,9 +756,8 @@
 	};
 
 	VK_CHECK(vk.beginCommandBuffer(*m_cmdBuffer, &cmdBufferBeginInfo));
-	vk.cmdPipelineBarrier(*m_cmdBuffer, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, (VkDependencyFlags)0, 0, (const VkMemoryBarrier*)DE_NULL, 0, (const VkBufferMemoryBarrier*)DE_NULL, 1, &srcImageBarrier);
+	vk.cmdPipelineBarrier(*m_cmdBuffer, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, (VkDependencyFlags)0, 0, (const VkMemoryBarrier*)DE_NULL, 0, (const VkBufferMemoryBarrier*)DE_NULL, DE_LENGTH_OF_ARRAY(imageBarriers), imageBarriers);
 	vk.cmdCopyImage(*m_cmdBuffer, m_source.get(), VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, m_destination.get(), VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, (deUint32)m_params.regions.size(), imageCopies);
-	vk.cmdPipelineBarrier(*m_cmdBuffer, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, (VkDependencyFlags)0, 0, (const VkMemoryBarrier*)DE_NULL, 0, (const VkBufferMemoryBarrier*)DE_NULL, 1, &dstImageBarrier);
 	VK_CHECK(vk.endCommandBuffer(*m_cmdBuffer));
 
 	const VkSubmitInfo submitInfo =
@@ -1320,28 +1320,14 @@
 	const VkQueue				queue		= m_context.getUniversalQueue();
 	SimpleAllocator				memAlloc	(vk, vkDevice, getPhysicalDeviceMemoryProperties(m_context.getInstanceInterface(), m_context.getPhysicalDevice()));
 
-	// Barriers for copying image to buffer
-	const VkBufferMemoryBarrier bufferBarrier =
-	{
-		VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER,	// VkStructureType	sType;
-		DE_NULL,									// const void*		pNext;
-		VK_ACCESS_TRANSFER_WRITE_BIT,				// VkAccessFlags	srcAccessMask;
-		VK_ACCESS_HOST_READ_BIT,					// VkAccessFlags	dstAccessMask;
-		VK_QUEUE_FAMILY_IGNORED,					// deUint32			srcQueueFamilyIndex;
-		VK_QUEUE_FAMILY_IGNORED,					// deUint32			dstQueueFamilyIndex;
-		*m_source,									// VkBuffer			buffer;
-		0u,											// VkDeviceSize		offset;
-		m_bufferSize								// VkDeviceSize		size;
-	};
-
 	const VkImageMemoryBarrier imageBarrier =
 	{
 		VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,		// VkStructureType			sType;
 		DE_NULL,									// const void*				pNext;
 		VK_ACCESS_TRANSFER_WRITE_BIT,				// VkAccessFlags			srcAccessMask;
-		VK_ACCESS_TRANSFER_READ_BIT,				// VkAccessFlags			dstAccessMask;
+		VK_ACCESS_TRANSFER_WRITE_BIT,				// VkAccessFlags			dstAccessMask;
 		VK_IMAGE_LAYOUT_GENERAL,					// VkImageLayout			oldLayout;
-		VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,		// VkImageLayout			newLayout;
+		VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,		// VkImageLayout			newLayout;
 		VK_QUEUE_FAMILY_IGNORED,					// deUint32					srcQueueFamilyIndex;
 		VK_QUEUE_FAMILY_IGNORED,					// deUint32					dstQueueFamilyIndex;
 		*m_destination,								// VkImage					image;
@@ -1368,9 +1354,8 @@
 	};
 
 	VK_CHECK(vk.beginCommandBuffer(*m_cmdBuffer, &cmdBufferBeginInfo));
-	vk.cmdPipelineBarrier(*m_cmdBuffer, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, (VkDependencyFlags)0, 0, (const VkMemoryBarrier*)DE_NULL, 1, &bufferBarrier, 0, (const VkImageMemoryBarrier*)DE_NULL);
-	vk.cmdCopyBufferToImage(*m_cmdBuffer, m_source.get(), m_destination.get(), VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, (deUint32)m_params.regions.size(), bufferImageCopies);
 	vk.cmdPipelineBarrier(*m_cmdBuffer, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, (VkDependencyFlags)0, 0, (const VkMemoryBarrier*)DE_NULL, 0, (const VkBufferMemoryBarrier*)DE_NULL, 1, &imageBarrier);
+	vk.cmdCopyBufferToImage(*m_cmdBuffer, m_source.get(), m_destination.get(), VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, (deUint32)m_params.regions.size(), bufferImageCopies);
 	VK_CHECK(vk.endCommandBuffer(*m_cmdBuffer));
 
 	const VkSubmitInfo				submitInfo		=
@@ -1390,7 +1375,6 @@
 	VK_CHECK(vk.queueSubmit(queue, 1, &submitInfo, *m_fence));
 	VK_CHECK(vk.waitForFences(vkDevice, 1, &m_fence.get(), true, ~(0ull) /* infinity */));
 
-	// Read buffer data
 	de::MovePtr<tcu::TextureLevel>	resultLevel	= readImage(vk, vkDevice, queue, memAlloc, *m_destination, m_params.dst.image.format, m_params.dst.image.extent);
 	deFree(bufferImageCopies);
 
@@ -1710,8 +1694,8 @@
 		params.src.buffer.size = size;
 		params.dst.buffer.size = size * (size + 1);
 
-		// Copy region with size 0..size
-		for (unsigned int i = 0; i <= size; i++)
+		// Copy region with size 1..size
+		for (unsigned int i = 1; i <= size; i++)
 		{
 			const VkBufferCopy bufferCopy = {
 				0,		// VkDeviceSize	srcOffset;
diff --git a/external/vulkancts/modules/vulkan/api/vktApiFeatureInfo.cpp b/external/vulkancts/modules/vulkan/api/vktApiFeatureInfo.cpp
index 369745d..35c735f 100644
--- a/external/vulkancts/modules/vulkan/api/vktApiFeatureInfo.cpp
+++ b/external/vulkancts/modules/vulkan/api/vktApiFeatureInfo.cpp
@@ -40,6 +40,7 @@
 #include "tcuResultCollector.hpp"
 
 #include "deUniquePtr.hpp"
+#include "deString.h"
 #include "deStringUtil.hpp"
 #include "deSTLUtil.hpp"
 #include "deMemory.h"
@@ -822,6 +823,13 @@
 		return tcu::TestStatus::fail("deviceProperties incomplete initialization");
 	}
 
+	// Check if deviceName string is properly terminated.
+	if (deStrnlen(props->deviceName, VK_MAX_PHYSICAL_DEVICE_NAME_SIZE) == VK_MAX_PHYSICAL_DEVICE_NAME_SIZE)
+	{
+		log << TestLog::Message << "deviceProperties - VkPhysicalDeviceProperties deviceName not properly initialized" << TestLog::EndMessage;
+		return tcu::TestStatus::fail("deviceProperties incomplete initialization");
+	}
+
 	{
 		const ApiVersion deviceVersion = unpackVersion(props->apiVersion);
 		const ApiVersion deqpVersion = unpackVersion(VK_API_VERSION);
diff --git a/external/vulkancts/modules/vulkan/api/vktApiObjectManagementTests.cpp b/external/vulkancts/modules/vulkan/api/vktApiObjectManagementTests.cpp
index 6d3f159..b65821a 100644
--- a/external/vulkancts/modules/vulkan/api/vktApiObjectManagementTests.cpp
+++ b/external/vulkancts/modules/vulkan/api/vktApiObjectManagementTests.cpp
@@ -1484,8 +1484,8 @@
 			VK_FALSE,								// stencilTestEnable
 			{ VK_STENCIL_OP_KEEP, VK_STENCIL_OP_KEEP, VK_STENCIL_OP_KEEP, VK_COMPARE_OP_ALWAYS, 0u, 0u, 0u },
 			{ VK_STENCIL_OP_KEEP, VK_STENCIL_OP_KEEP, VK_STENCIL_OP_KEEP, VK_COMPARE_OP_ALWAYS, 0u, 0u, 0u },
-			-1.0f,									// minDepthBounds
-			+1.0f,									// maxDepthBounds
+			0.0f,									// minDepthBounds
+			1.0f,									// maxDepthBounds
 		};
 		const VkPipelineColorBlendAttachmentState		colorBlendAttState[]=
 		{
diff --git a/external/vulkancts/modules/vulkan/api/vktApiSmokeTests.cpp b/external/vulkancts/modules/vulkan/api/vktApiSmokeTests.cpp
index d48b7d6..21aae8f 100644
--- a/external/vulkancts/modules/vulkan/api/vktApiSmokeTests.cpp
+++ b/external/vulkancts/modules/vulkan/api/vktApiSmokeTests.cpp
@@ -403,8 +403,8 @@
 			0u,															// writeMask
 			0u,															// reference
 		},															// back;
-		-1.0f,														//	float				minDepthBounds;
-		+1.0f,														//	float				maxDepthBounds;
+		0.0f,														//	float				minDepthBounds;
+		1.0f,														//	float				maxDepthBounds;
 	};
 	const VkViewport						viewport0				=
 	{
diff --git a/external/vulkancts/modules/vulkan/binding_model/vktBindingShaderAccessTests.cpp b/external/vulkancts/modules/vulkan/binding_model/vktBindingShaderAccessTests.cpp
index aec26b2..f997214 100644
--- a/external/vulkancts/modules/vulkan/binding_model/vktBindingShaderAccessTests.cpp
+++ b/external/vulkancts/modules/vulkan/binding_model/vktBindingShaderAccessTests.cpp
@@ -676,8 +676,16 @@
 			vk::VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT,	// flags
 			(const vk::VkCommandBufferInheritanceInfo*)DE_NULL,
 		};
+		const vk::VkFenceCreateInfo				fenceCreateInfo				=
+		{
+			vk::VK_STRUCTURE_TYPE_FENCE_CREATE_INFO,
+			DE_NULL,
+			(vk::VkFenceCreateFlags)0,
+		};
 
 		const vk::Unique<vk::VkCommandBuffer>	cmd					(vk::allocateCommandBuffer(m_vki, m_device, &cmdBufAllocInfo));
+		const vk::Unique<vk::VkFence>			fence				(vk::createFence(m_vki, m_device, &fenceCreateInfo));
+		const deUint64							infiniteTimeout		= ~(deUint64)0u;
 
 		VK_CHECK(m_vki.beginCommandBuffer(*cmd, &cmdBufBeginInfo));
 		m_vki.cmdPipelineBarrier(*cmd, vk::VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, vk::VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, (vk::VkDependencyFlags)0,
@@ -700,8 +708,9 @@
 				(const vk::VkSemaphore*)0,
 			};
 
-			VK_CHECK(m_vki.queueSubmit(m_queue, 1, &submitInfo, (vk::VkFence)0));
+			VK_CHECK(m_vki.queueSubmit(m_queue, 1u, &submitInfo, *fence));
 		}
+		VK_CHECK(m_vki.waitForFences(m_device, 1u, &fence.get(), vk::VK_TRUE, infiniteTimeout));
 
 		// and then render to
 		renderToTarget();
@@ -1288,6 +1297,8 @@
 
 	flushMappedMemoryRange(vki, device, bufferMemory->getMemory(), bufferMemory->getOffset(), bufferSize);
 
+	// Flushed host-visible memory is automatically made available to the GPU, no barrier is needed.
+
 	*outMemory = bufferMemory;
 	return buffer;
 }
@@ -1455,8 +1466,6 @@
 
 void BufferRenderInstance::writeDrawCmdBuffer (vk::VkCommandBuffer cmd) const
 {
-	const bool							isUniformBuffer		= isUniformDescriptorType(m_descriptorType);
-
 	// \note dynamic offset replaces the view offset, i.e. it is not offset relative to the view offset
 	const deUint32						dynamicOffsets[]	=
 	{
@@ -1466,40 +1475,7 @@
 	const deUint32						numOffsets			= (!m_setDynamicOffset) ? (0u) : (getInterfaceNumResources(m_shaderInterface));
 	const deUint32* const				dynamicOffsetPtr	= (!m_setDynamicOffset) ? (DE_NULL) : (dynamicOffsets);
 
-	// make host writes device-visible
-	const vk::VkAccessFlags				inputBit			= (isUniformBuffer) ? (vk::VK_ACCESS_UNIFORM_READ_BIT) : (vk::VK_ACCESS_SHADER_READ_BIT);
-	const vk::VkBufferMemoryBarrier		memoryBarriers[]	=
-	{
-		{
-			vk::VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER,
-			DE_NULL,
-			vk::VK_ACCESS_HOST_WRITE_BIT,				// outputMask
-			inputBit,									// inputMask
-			vk::VK_QUEUE_FAMILY_IGNORED,				// srcQueueFamilyIndex
-			vk::VK_QUEUE_FAMILY_IGNORED,				// destQueueFamilyIndex
-			*m_sourceBufferA,							// buffer
-			0u,											// offset
-			(vk::VkDeviceSize)m_bufferSizeA,			// size
-		},
-		{
-			vk::VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER,
-			DE_NULL,
-			vk::VK_ACCESS_HOST_WRITE_BIT,				// outputMask
-			inputBit,									// inputMask
-			vk::VK_QUEUE_FAMILY_IGNORED,				// srcQueueFamilyIndex
-			vk::VK_QUEUE_FAMILY_IGNORED,				// destQueueFamilyIndex
-			*m_sourceBufferB,							// buffer
-			0u,											// offset
-			(vk::VkDeviceSize)m_bufferSizeB,			// size
-		}
-	};
-	const deUint32						numMemoryBarriers	= getInterfaceNumResources(m_shaderInterface);
-
 	m_vki.cmdBindDescriptorSets(cmd, vk::VK_PIPELINE_BIND_POINT_GRAPHICS, getPipelineLayout(), 0, 1, &m_descriptorSet.get(), numOffsets, dynamicOffsetPtr);
-	m_vki.cmdPipelineBarrier(cmd, 0u, vk::VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT, (vk::VkDependencyFlags)0,
-							 0, (const vk::VkMemoryBarrier*)DE_NULL,
-							 numMemoryBarriers, memoryBarriers,
-							 0, (const vk::VkImageMemoryBarrier*)DE_NULL);
 	m_vki.cmdDraw(cmd, 6 * 4, 1, 0, 0); // render four quads (two separate triangles)
 }
 
@@ -1806,7 +1782,7 @@
 	m_vki.cmdBindDescriptorSets(*cmd, vk::VK_PIPELINE_BIND_POINT_COMPUTE, m_pipelineLayout, 0, m_numDescriptorSets, m_descriptorSets, m_numDynamicOffsets, m_dynamicOffsets);
 
 	if (m_numPreBarriers)
-		m_vki.cmdPipelineBarrier(*cmd, 0u, vk::VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT, (vk::VkDependencyFlags)0,
+		m_vki.cmdPipelineBarrier(*cmd, vk::VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, vk::VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT, (vk::VkDependencyFlags)0,
 								 0, (const vk::VkMemoryBarrier*)DE_NULL,
 								 m_numPreBarriers, m_preBarriers,
 								 0, (const vk::VkImageMemoryBarrier*)DE_NULL);
@@ -2261,19 +2237,21 @@
 
 	if ((m_activeStages & vk::VK_SHADER_STAGE_VERTEX_BIT) != 0u)
 	{
+		const bool onlyVS = (m_activeStages == vk::VK_SHADER_STAGE_VERTEX_BIT);
+
 		// active vertex shader
 		buf << versionDecl << "\n"
 			<< genExtensionDeclarations(vk::VK_SHADER_STAGE_VERTEX_BIT)
 			<< genResourceDeclarations(vk::VK_SHADER_STAGE_VERTEX_BIT, 0)
 			<< "layout(location = 0) out highp vec4 " << nextStageName << "_color;\n"
-			<< "layout(location = 1) flat out highp int " << nextStageName << "_quadrant_id;\n"
+			<< (onlyVS ? "" : "layout(location = 1) flat out highp int " + de::toString(nextStageName) + "_quadrant_id;\n")
 			<< "void main (void)\n"
 			<< "{\n"
 			<< "	highp vec4 result_position;\n"
 			<< "	highp int quadrant_id;\n"
 			<< s_quadrantGenVertexPosSource
 			<< "	gl_Position = result_position;\n"
-			<< "	" << nextStageName << "_quadrant_id = quadrant_id;\n"
+			<< (onlyVS ? "" : "\t" + de::toString(nextStageName) + "_quadrant_id = quadrant_id;\n")
 			<< "\n"
 			<< "	highp vec4 result_color;\n"
 			<< genResourceAccessSource(vk::VK_SHADER_STAGE_VERTEX_BIT)
@@ -2578,7 +2556,7 @@
 		<< "{\n"
 		<< "	highp vec4 read_colors[4];\n"
 		<< "} b_out;\n"
-		<< "void main(void)\n"
+		<< "void main (void)\n"
 		<< "{\n"
 		<< "	highp int quadrant_id = int(gl_WorkGroupID.x);\n"
 		<< "	highp vec4 result_color;\n"
@@ -3082,7 +3060,7 @@
 		vk::VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,
 		DE_NULL,
 		0u,													// outputMask
-		0u,													// inputMask
+		vk::VK_ACCESS_TRANSFER_WRITE_BIT,					// inputMask
 		vk::VK_IMAGE_LAYOUT_UNDEFINED,						// oldLayout
 		vk::VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,			// newLayout
 		vk::VK_QUEUE_FAMILY_IGNORED,						// srcQueueFamilyIndex
@@ -3138,7 +3116,7 @@
 
 	// record command buffer
 	VK_CHECK(vki.beginCommandBuffer(*cmd, &cmdBufBeginInfo));
-	vki.cmdPipelineBarrier(*cmd, 0u, vk::VK_PIPELINE_STAGE_TRANSFER_BIT, (vk::VkDependencyFlags)0,
+	vki.cmdPipelineBarrier(*cmd, vk::VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, vk::VK_PIPELINE_STAGE_TRANSFER_BIT, (vk::VkDependencyFlags)0,
 						   0, (const vk::VkMemoryBarrier*)DE_NULL,
 						   1, &preMemoryBarrier,
 						   1, &preImageBarrier);
diff --git a/external/vulkancts/modules/vulkan/dynamic_state/vktDynamicStateDSTests.cpp b/external/vulkancts/modules/vulkan/dynamic_state/vktDynamicStateDSTests.cpp
index 4f479f8..5fe145d 100644
--- a/external/vulkancts/modules/vulkan/dynamic_state/vktDynamicStateDSTests.cpp
+++ b/external/vulkancts/modules/vulkan/dynamic_state/vktDynamicStateDSTests.cpp
@@ -311,7 +311,7 @@
 		m_vk.beginCommandBuffer(*m_cmdBuffer, &beginInfo);
 
 		initialTransitionColor2DImage(m_vk, *m_cmdBuffer, m_colorTargetImage->object(), vk::VK_IMAGE_LAYOUT_GENERAL);
-		initialTransitionDepthStencil2DImage(m_vk, *m_cmdBuffer, m_depthStencilImage->object(), vk::VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL);
+		initialTransitionDepthStencil2DImage(m_vk, *m_cmdBuffer, m_depthStencilImage->object(), vk::VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 0, vk::VK_ACCESS_TRANSFER_WRITE_BIT);
 
 		const ImageSubresourceRange subresourceRangeImage(vk::VK_IMAGE_ASPECT_COLOR_BIT);
 		m_vk.cmdClearColorImage(*m_cmdBuffer, m_colorTargetImage->object(),
@@ -338,6 +338,8 @@
 		const vk::VkRect2D renderArea = { { 0, 0 }, { WIDTH, HEIGHT } };
 		const RenderPassBeginInfo renderPassBegin(*m_renderPass, *m_framebuffer, renderArea);
 
+		transition2DImage(m_vk, *m_cmdBuffer, m_depthStencilImage->object(), vk::VK_IMAGE_ASPECT_DEPTH_BIT | vk::VK_IMAGE_ASPECT_STENCIL_BIT, vk::VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, vk::VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL, vk::VK_ACCESS_TRANSFER_WRITE_BIT, vk::VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT);
+
 		m_vk.cmdBeginRenderPass(*m_cmdBuffer, &renderPassBegin, vk::VK_SUBPASS_CONTENTS_INLINE);
 	}
 
diff --git a/external/vulkancts/modules/vulkan/dynamic_state/vktDynamicStateImageObjectUtil.cpp b/external/vulkancts/modules/vulkan/dynamic_state/vktDynamicStateImageObjectUtil.cpp
index 99014d3..e00b5b1 100644
--- a/external/vulkancts/modules/vulkan/dynamic_state/vktDynamicStateImageObjectUtil.cpp
+++ b/external/vulkancts/modules/vulkan/dynamic_state/vktDynamicStateImageObjectUtil.cpp
@@ -876,22 +876,24 @@
 }
 
 void transition2DImage (const vk::DeviceInterface&	vk,
-						vk::VkCommandBuffer				cmdBuffer,
+						vk::VkCommandBuffer			cmdBuffer,
 						vk::VkImage					image,
 						vk::VkImageAspectFlags		aspectMask,
 						vk::VkImageLayout			oldLayout,
-						vk::VkImageLayout			newLayout)
+						vk::VkImageLayout			newLayout,
+						vk::VkAccessFlags			srcAccessMask,
+						vk::VkAccessFlags			dstAccessMask)
 {
 	vk::VkImageMemoryBarrier barrier;
-	barrier.sType					= vk::VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER;
-	barrier.pNext					= DE_NULL;
-	barrier.srcAccessMask				= 0;
-	barrier.dstAccessMask				= 0;
-	barrier.oldLayout				= oldLayout;
-	barrier.newLayout				= newLayout;
-	barrier.srcQueueFamilyIndex		= vk::VK_QUEUE_FAMILY_IGNORED;
-	barrier.dstQueueFamilyIndex	= vk::VK_QUEUE_FAMILY_IGNORED;
-	barrier.image					= image;
+	barrier.sType							= vk::VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER;
+	barrier.pNext							= DE_NULL;
+	barrier.srcAccessMask					= srcAccessMask;
+	barrier.dstAccessMask					= dstAccessMask;
+	barrier.oldLayout						= oldLayout;
+	barrier.newLayout						= newLayout;
+	barrier.srcQueueFamilyIndex				= vk::VK_QUEUE_FAMILY_IGNORED;
+	barrier.dstQueueFamilyIndex				= vk::VK_QUEUE_FAMILY_IGNORED;
+	barrier.image							= image;
 	barrier.subresourceRange.aspectMask		= aspectMask;
 	barrier.subresourceRange.baseMipLevel	= 0;
 	barrier.subresourceRange.levelCount		= 1;
@@ -919,9 +921,14 @@
 	transition2DImage(vk, cmdBuffer, image, vk::VK_IMAGE_ASPECT_STENCIL_BIT, vk::VK_IMAGE_LAYOUT_UNDEFINED, layout);
 }
 
-void initialTransitionDepthStencil2DImage (const vk::DeviceInterface &vk, vk::VkCommandBuffer cmdBuffer, vk::VkImage image, vk::VkImageLayout layout)
+void initialTransitionDepthStencil2DImage (const vk::DeviceInterface&	vk,
+										   vk::VkCommandBuffer			cmdBuffer,
+										   vk::VkImage					image,
+										   vk::VkImageLayout			layout,
+										   vk::VkAccessFlags			srcAccessMask,
+										   vk::VkAccessFlags			dstAccessMask)
 {
-	transition2DImage(vk, cmdBuffer, image, vk::VK_IMAGE_ASPECT_DEPTH_BIT | vk::VK_IMAGE_ASPECT_STENCIL_BIT, vk::VK_IMAGE_LAYOUT_UNDEFINED, layout);
+	transition2DImage(vk, cmdBuffer, image, vk::VK_IMAGE_ASPECT_DEPTH_BIT | vk::VK_IMAGE_ASPECT_STENCIL_BIT, vk::VK_IMAGE_LAYOUT_UNDEFINED, layout, srcAccessMask, dstAccessMask);
 }
 
 } // DynamicState
diff --git a/external/vulkancts/modules/vulkan/dynamic_state/vktDynamicStateImageObjectUtil.hpp b/external/vulkancts/modules/vulkan/dynamic_state/vktDynamicStateImageObjectUtil.hpp
index 144abee..952c500 100644
--- a/external/vulkancts/modules/vulkan/dynamic_state/vktDynamicStateImageObjectUtil.hpp
+++ b/external/vulkancts/modules/vulkan/dynamic_state/vktDynamicStateImageObjectUtil.hpp
@@ -261,7 +261,14 @@
 	vk::VkDevice				m_device;
 };
 
-void transition2DImage (const vk::DeviceInterface& vk, vk::VkCommandBuffer cmdBuffer, vk::VkImage image, vk::VkImageAspectFlags aspectMask, vk::VkImageLayout oldLayout, vk::VkImageLayout newLayout);
+void transition2DImage (const vk::DeviceInterface&	vk,
+						vk::VkCommandBuffer			cmdBuffer,
+						vk::VkImage					image,
+						vk::VkImageAspectFlags		aspectMask,
+						vk::VkImageLayout			oldLayout,
+						vk::VkImageLayout			newLayout,
+						vk::VkAccessFlags			srcAccessMask = 0,
+						vk::VkAccessFlags			dstAccessMask = 0);
 
 void initialTransitionColor2DImage (const vk::DeviceInterface& vk, vk::VkCommandBuffer cmdBuffer, vk::VkImage image, vk::VkImageLayout layout);
 
@@ -269,7 +276,12 @@
 
 void initialTransitionStencil2DImage (const vk::DeviceInterface& vk, vk::VkCommandBuffer cmdBuffer, vk::VkImage image, vk::VkImageLayout layout);
 
-void initialTransitionDepthStencil2DImage (const vk::DeviceInterface& vk, vk::VkCommandBuffer cmdBuffer, vk::VkImage image, vk::VkImageLayout layout);
+void initialTransitionDepthStencil2DImage (const vk::DeviceInterface&	vk,
+										   vk::VkCommandBuffer			cmdBuffer,
+										   vk::VkImage					image,
+										   vk::VkImageLayout			layout,
+										   vk::VkAccessFlags			srcAccessMask = 0,
+										   vk::VkAccessFlags			dstAccessMask = 0);
 
 } // DynamicState
 } // vkt
diff --git a/external/vulkancts/modules/vulkan/dynamic_state/vktDynamicStateRSTests.cpp b/external/vulkancts/modules/vulkan/dynamic_state/vktDynamicStateRSTests.cpp
index 903a2eb..016d715 100644
--- a/external/vulkancts/modules/vulkan/dynamic_state/vktDynamicStateRSTests.cpp
+++ b/external/vulkancts/modules/vulkan/dynamic_state/vktDynamicStateRSTests.cpp
@@ -283,7 +283,7 @@
 		m_vk.beginCommandBuffer(*m_cmdBuffer, &beginInfo);
 
 		initialTransitionColor2DImage(m_vk, *m_cmdBuffer, m_colorTargetImage->object(), vk::VK_IMAGE_LAYOUT_GENERAL);
-		initialTransitionDepthStencil2DImage(m_vk, *m_cmdBuffer, m_depthStencilImage->object(), vk::VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL);
+		initialTransitionDepthStencil2DImage(m_vk, *m_cmdBuffer, m_depthStencilImage->object(), vk::VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 0, vk::VK_ACCESS_TRANSFER_WRITE_BIT);
 
 		const ImageSubresourceRange subresourceRangeImage(vk::VK_IMAGE_ASPECT_COLOR_BIT);
 		m_vk.cmdClearColorImage(*m_cmdBuffer, m_colorTargetImage->object(),
@@ -292,6 +292,7 @@
 		const vk::VkClearDepthStencilValue depthStencilClearValue = { 0.0f, 0 };
 
 		const ImageSubresourceRange subresourceRangeDepthStencil[2] = { vk::VK_IMAGE_ASPECT_DEPTH_BIT, vk::VK_IMAGE_ASPECT_STENCIL_BIT };
+		
 		m_vk.cmdClearDepthStencilImage(*m_cmdBuffer, m_depthStencilImage->object(),
 									   vk::VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, &depthStencilClearValue, 2, subresourceRangeDepthStencil);
 
@@ -312,6 +313,8 @@
 		const vk::VkRect2D renderArea = { { 0, 0 }, { WIDTH, HEIGHT } };
 		const RenderPassBeginInfo renderPassBegin(*m_renderPass, *m_framebuffer, renderArea);
 
+		transition2DImage(m_vk, *m_cmdBuffer, m_depthStencilImage->object(), vk::VK_IMAGE_ASPECT_DEPTH_BIT | vk::VK_IMAGE_ASPECT_STENCIL_BIT, vk::VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, vk::VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL, vk::VK_ACCESS_TRANSFER_WRITE_BIT, vk::VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT);
+
 		m_vk.cmdBeginRenderPass(*m_cmdBuffer, &renderPassBegin, vk::VK_SUBPASS_CONTENTS_INLINE);
 	}
 
diff --git a/external/vulkancts/modules/vulkan/query_pool/vktQueryPoolImageObjectUtil.cpp b/external/vulkancts/modules/vulkan/query_pool/vktQueryPoolImageObjectUtil.cpp
index 8d60645..4b15ecf 100644
--- a/external/vulkancts/modules/vulkan/query_pool/vktQueryPoolImageObjectUtil.cpp
+++ b/external/vulkancts/modules/vulkan/query_pool/vktQueryPoolImageObjectUtil.cpp
@@ -162,30 +162,6 @@
 {
 }
 
-tcu::ConstPixelBufferAccess Image::readSurface (vk::VkQueue					queue,
-												vk::Allocator&				allocator,
-												vk::VkImageLayout			layout,
-												vk::VkOffset3D				offset,
-												int							width,
-												int							height,
-												vk::VkImageAspectFlagBits	aspect,
-												unsigned int				mipLevel,
-												unsigned int				arrayElement)
-{
-	m_pixelAccessData.resize(width * height * vk::mapVkFormat(m_format).getPixelSize());
-	deMemset(m_pixelAccessData.data(), 0, m_pixelAccessData.size());
-	if (aspect == vk::VK_IMAGE_ASPECT_COLOR_BIT)
-	{
-		read(queue, allocator, layout, offset, width, height, 1, mipLevel, arrayElement, aspect, vk::VK_IMAGE_TYPE_2D,
-		m_pixelAccessData.data());
-	}
-	if (aspect == vk::VK_IMAGE_ASPECT_DEPTH_BIT || aspect == vk::VK_IMAGE_ASPECT_STENCIL_BIT)
-	{
-		readUsingBuffer(queue, allocator, layout, offset, width, height, 1, mipLevel, arrayElement, aspect, m_pixelAccessData.data());
-	}
-	return tcu::ConstPixelBufferAccess(vk::mapVkFormat(m_format), width, height, 1, m_pixelAccessData.data());
-}
-
 tcu::ConstPixelBufferAccess Image::readVolume (vk::VkQueue					queue,
 											   vk::Allocator&				allocator,
 											   vk::VkImageLayout			layout,
@@ -455,7 +431,7 @@
 		CmdBufferBeginInfo beginInfo;
 		VK_CHECK(m_vk.beginCommandBuffer(*copyCmdBuffer, &beginInfo));
 
-		transition2DImage(m_vk, *copyCmdBuffer, stagingResource->object(), aspect, vk::VK_IMAGE_LAYOUT_UNDEFINED, vk::VK_IMAGE_LAYOUT_GENERAL);
+		transition2DImage(m_vk, *copyCmdBuffer, stagingResource->object(), aspect, vk::VK_IMAGE_LAYOUT_UNDEFINED, vk::VK_IMAGE_LAYOUT_GENERAL, 0, vk::VK_ACCESS_TRANSFER_WRITE_BIT);
 
 		const vk::VkOffset3D zeroOffset = { 0, 0, 0 };
 		vk::VkImageCopy region = { {aspect, mipLevel, arrayElement, 1}, offset, {aspect, 0, 0, 1}, zeroOffset, {(deUint32)width, (deUint32)height, (deUint32)depth} };
@@ -879,22 +855,24 @@
 }
 
 void transition2DImage (const vk::DeviceInterface&	vk,
-						vk::VkCommandBuffer				cmdBuffer,
+						vk::VkCommandBuffer			cmdBuffer,
 						vk::VkImage					image,
 						vk::VkImageAspectFlags		aspectMask,
 						vk::VkImageLayout			oldLayout,
-						vk::VkImageLayout			newLayout)
+						vk::VkImageLayout			newLayout,
+						vk::VkAccessFlags			srcAccessMask,
+						vk::VkAccessFlags			dstAccessMask)
 {
 	vk::VkImageMemoryBarrier barrier;
-	barrier.sType					= vk::VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER;
-	barrier.pNext					= DE_NULL;
-	barrier.srcAccessMask				= 0;
-	barrier.dstAccessMask				= 0;
-	barrier.oldLayout				= oldLayout;
-	barrier.newLayout				= newLayout;
-	barrier.srcQueueFamilyIndex		= vk::VK_QUEUE_FAMILY_IGNORED;
-	barrier.dstQueueFamilyIndex	= vk::VK_QUEUE_FAMILY_IGNORED;
-	barrier.image					= image;
+	barrier.sType							= vk::VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER;
+	barrier.pNext							= DE_NULL;
+	barrier.srcAccessMask					= srcAccessMask;
+	barrier.dstAccessMask					= dstAccessMask;
+	barrier.oldLayout						= oldLayout;
+	barrier.newLayout						= newLayout;
+	barrier.srcQueueFamilyIndex				= vk::VK_QUEUE_FAMILY_IGNORED;
+	barrier.dstQueueFamilyIndex				= vk::VK_QUEUE_FAMILY_IGNORED;
+	barrier.image							= image;
 	barrier.subresourceRange.aspectMask		= aspectMask;
 	barrier.subresourceRange.baseMipLevel	= 0;
 	barrier.subresourceRange.levelCount		= 1;
diff --git a/external/vulkancts/modules/vulkan/query_pool/vktQueryPoolImageObjectUtil.hpp b/external/vulkancts/modules/vulkan/query_pool/vktQueryPoolImageObjectUtil.hpp
index 72e7ef7..8e5871d 100644
--- a/external/vulkancts/modules/vulkan/query_pool/vktQueryPoolImageObjectUtil.hpp
+++ b/external/vulkancts/modules/vulkan/query_pool/vktQueryPoolImageObjectUtil.hpp
@@ -69,16 +69,6 @@
 													 vk::Allocator&							allocator,
 													 vk::MemoryRequirement					memoryRequirement = vk::MemoryRequirement::Any);
 
-	tcu::ConstPixelBufferAccess readSurface			(vk::VkQueue							queue,
-													 vk::Allocator&							allocator,
-													 vk::VkImageLayout						layout,
-													 vk::VkOffset3D							offset,
-													 int									width,
-													 int									height,
-													 vk::VkImageAspectFlagBits				aspect,
-													 unsigned int							mipLevel = 0,
-													 unsigned int							arrayElement = 0);
-
 	tcu::ConstPixelBufferAccess readSurface1D		(vk::VkQueue							queue,
 													 vk::Allocator&							allocator,
 													 vk::VkImageLayout						layout,
@@ -260,7 +250,14 @@
 	vk::VkDevice				m_device;
 };
 
-void transition2DImage (const vk::DeviceInterface& vk, vk::VkCommandBuffer cmdBuffer, vk::VkImage image, vk::VkImageAspectFlags aspectMask, vk::VkImageLayout oldLayout, vk::VkImageLayout newLayout);
+void transition2DImage (const vk::DeviceInterface&	vk,
+						vk::VkCommandBuffer			cmdBuffer,
+						vk::VkImage					image,
+						vk::VkImageAspectFlags		aspectMask,
+						vk::VkImageLayout			oldLayout,
+						vk::VkImageLayout			newLayout,
+						vk::VkAccessFlags			srcAccessMask = 0,
+						vk::VkAccessFlags			dstAccessMask = 0);
 
 void initialTransitionColor2DImage (const vk::DeviceInterface& vk, vk::VkCommandBuffer cmdBuffer, vk::VkImage image, vk::VkImageLayout layout);
 
diff --git a/external/vulkancts/modules/vulkan/query_pool/vktQueryPoolOcclusionTests.cpp b/external/vulkancts/modules/vulkan/query_pool/vktQueryPoolOcclusionTests.cpp
index 6b324e7..22feecc 100644
--- a/external/vulkancts/modules/vulkan/query_pool/vktQueryPoolOcclusionTests.cpp
+++ b/external/vulkancts/modules/vulkan/query_pool/vktQueryPoolOcclusionTests.cpp
@@ -374,8 +374,8 @@
 
 	vk.beginCommandBuffer(*cmdBuffer, &beginInfo);
 
-	transition2DImage(vk, *cmdBuffer, m_stateObjects->m_colorAttachmentImage->object(), vk::VK_IMAGE_ASPECT_COLOR_BIT, vk::VK_IMAGE_LAYOUT_UNDEFINED, vk::VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL);
-	transition2DImage(vk, *cmdBuffer, m_stateObjects->m_DepthImage->object(), vk::VK_IMAGE_ASPECT_DEPTH_BIT, vk::VK_IMAGE_LAYOUT_UNDEFINED, vk::VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL);
+	transition2DImage(vk, *cmdBuffer, m_stateObjects->m_colorAttachmentImage->object(), vk::VK_IMAGE_ASPECT_COLOR_BIT, vk::VK_IMAGE_LAYOUT_UNDEFINED, vk::VK_IMAGE_LAYOUT_GENERAL, 0, vk::VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT);
+	transition2DImage(vk, *cmdBuffer, m_stateObjects->m_DepthImage->object(), vk::VK_IMAGE_ASPECT_DEPTH_BIT, vk::VK_IMAGE_LAYOUT_UNDEFINED, vk::VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL, 0, vk::VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT);
 
 	std::vector<vk::VkClearValue> renderPassClearValues(2);
 	deMemset(&renderPassClearValues[0], 0, static_cast<int>(renderPassClearValues.size()) * sizeof(vk::VkClearValue));
@@ -407,7 +407,7 @@
 
 	vk.cmdEndRenderPass(*cmdBuffer);
 
-	transition2DImage(vk, *cmdBuffer, m_stateObjects->m_colorAttachmentImage->object(), vk::VK_IMAGE_ASPECT_COLOR_BIT, vk::VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, vk::VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL);
+	transition2DImage(vk, *cmdBuffer, m_stateObjects->m_colorAttachmentImage->object(), vk::VK_IMAGE_ASPECT_COLOR_BIT, vk::VK_IMAGE_LAYOUT_GENERAL, vk::VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, vk::VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT, vk::VK_ACCESS_TRANSFER_READ_BIT);
 
 	vk.endCommandBuffer(*cmdBuffer);
 
@@ -492,14 +492,6 @@
 	}
 	log << tcu::TestLog::EndSection;
 
-	const vk::VkOffset3D zeroOffset = { 0, 0, 0 };
-
-	tcu::ConstPixelBufferAccess resultImageAccess = m_stateObjects->m_colorAttachmentImage->readSurface(
-				queue, m_context.getDefaultAllocator(), vk::VK_IMAGE_LAYOUT_GENERAL,
-				zeroOffset,  StateObjects::HEIGHT, StateObjects::WIDTH, vk::VK_IMAGE_ASPECT_COLOR_BIT);
-
-	log << tcu::TestLog::Image("Result", "Result", resultImageAccess);
-
 	if (passed)
 	{
 		return tcu::TestStatus(QP_TEST_RESULT_PASS, "Query result verification passed");
@@ -521,7 +513,6 @@
 	void							captureResults					(deUint64*			retResults,	deUint64*		retAvailability,	bool	allowNotReady);
 	void							logResults						(const deUint64*	results,	const deUint64* availability);
 	bool							validateResults					(const deUint64*	results,	const deUint64* availability,		bool	allowUnavailable,	vk::VkPrimitiveTopology primitiveTopology);
-	void							logRenderTarget					(void);
 
 	enum
 	{
@@ -702,7 +693,10 @@
 
 	log << tcu::TestLog::EndSection;
 
-	logRenderTarget();
+	if (m_testVector.queryResultsMode != RESULTS_MODE_COPY)
+	{
+		VK_CHECK(vk.queueWaitIdle(queue));
+	}
 
 		if (passed)
 	{
@@ -729,8 +723,8 @@
 
 	vk.beginCommandBuffer(*cmdBuffer, &beginInfo);
 
-	transition2DImage(vk, *cmdBuffer, m_stateObjects->m_colorAttachmentImage->object(), vk::VK_IMAGE_ASPECT_COLOR_BIT, vk::VK_IMAGE_LAYOUT_UNDEFINED, vk::VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL);
-	transition2DImage(vk, *cmdBuffer, m_stateObjects->m_DepthImage->object(), vk::VK_IMAGE_ASPECT_DEPTH_BIT, vk::VK_IMAGE_LAYOUT_UNDEFINED, vk::VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL);
+	transition2DImage(vk, *cmdBuffer, m_stateObjects->m_colorAttachmentImage->object(), vk::VK_IMAGE_ASPECT_COLOR_BIT, vk::VK_IMAGE_LAYOUT_UNDEFINED, vk::VK_IMAGE_LAYOUT_GENERAL, 0, vk::VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT);
+	transition2DImage(vk, *cmdBuffer, m_stateObjects->m_DepthImage->object(), vk::VK_IMAGE_ASPECT_DEPTH_BIT, vk::VK_IMAGE_LAYOUT_UNDEFINED, vk::VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL, 0, vk::VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT);
 
 	std::vector<vk::VkClearValue>	renderPassClearValues(2);
 	deMemset(&renderPassClearValues[0], 0, static_cast<int>(renderPassClearValues.size()) * sizeof(vk::VkClearValue));
@@ -785,7 +779,7 @@
 		}
 	}
 
-	transition2DImage(vk, *cmdBuffer, m_stateObjects->m_colorAttachmentImage->object(), vk::VK_IMAGE_ASPECT_COLOR_BIT, vk::VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, vk::VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL);
+	transition2DImage(vk, *cmdBuffer, m_stateObjects->m_colorAttachmentImage->object(), vk::VK_IMAGE_ASPECT_COLOR_BIT, vk::VK_IMAGE_LAYOUT_GENERAL, vk::VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, vk::VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT, vk::VK_ACCESS_TRANSFER_READ_BIT);
 
 	vk.endCommandBuffer(*cmdBuffer);
 
@@ -986,18 +980,6 @@
 	return passed;
 }
 
-void OcclusionQueryTestInstance::logRenderTarget (void)
-{
-	tcu::TestLog&			log						= m_context.getTestContext().getLog();
-	const vk::VkQueue		queue					= m_context.getUniversalQueue();
-	const vk::VkOffset3D	zeroOffset				= { 0, 0, 0 };
-	tcu::ConstPixelBufferAccess resultImageAccess	= m_stateObjects->m_colorAttachmentImage->readSurface(
-		queue, m_context.getDefaultAllocator(), vk::VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,
-		zeroOffset, StateObjects::HEIGHT, StateObjects::WIDTH, vk::VK_IMAGE_ASPECT_COLOR_BIT);
-
-	log << tcu::TestLog::Image("Result", "Result", resultImageAccess);
-}
-
 template<class Instance>
 class QueryPoolOcclusionTest : public vkt::TestCase
 {
diff --git a/external/vulkancts/modules/vulkan/shaderexecutor/vktShaderExecutor.cpp b/external/vulkancts/modules/vulkan/shaderexecutor/vktShaderExecutor.cpp
index 10e2bfd..4302e28 100644
--- a/external/vulkancts/modules/vulkan/shaderexecutor/vktShaderExecutor.cpp
+++ b/external/vulkancts/modules/vulkan/shaderexecutor/vktShaderExecutor.cpp
@@ -764,9 +764,10 @@
 
 		for (int outNdx = 0; outNdx < (int)m_outputLayout.locationSymbols.size(); ++outNdx)
 		{
-			bool												isFloat = isDataTypeFloatOrVec(m_shaderSpec.outputs[outNdx].varType.getBasicType());
-			bool												isSigned = isDataTypeIntOrIVec(m_shaderSpec.outputs[outNdx].varType.getBasicType());
-			VkFormat											colorFormat = isFloat ? VK_FORMAT_R32G32B32A32_SFLOAT : (isSigned ? VK_FORMAT_R32G32B32A32_SINT : VK_FORMAT_R32G32B32A32_UINT);
+			const bool		isFloat		= isDataTypeFloatOrVec(m_shaderSpec.outputs[outNdx].varType.getBasicType());
+			const bool		isSigned	= isDataTypeIntOrIVec (m_shaderSpec.outputs[outNdx].varType.getBasicType());
+			const bool		isBool		= isDataTypeBoolOrBVec(m_shaderSpec.outputs[outNdx].varType.getBasicType());
+			const VkFormat	colorFormat = isFloat ? VK_FORMAT_R32G32B32A32_SFLOAT : (isSigned || isBool ? VK_FORMAT_R32G32B32A32_SINT : VK_FORMAT_R32G32B32A32_UINT);
 
 			const VkImageCreateInfo	 colorImageParams =
 			{
@@ -2284,7 +2285,7 @@
 			VK_ATTACHMENT_STORE_OP_STORE,						// VkAttachmentStoreOp			storeOp;
 			VK_ATTACHMENT_LOAD_OP_DONT_CARE,					// VkAttachmentLoadOp			stencilLoadOp;
 			VK_ATTACHMENT_STORE_OP_DONT_CARE,					// VkAttachmentStoreOp			stencilStoreOp;
-			VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,			// VkImageLayout				initialLayout;
+			VK_IMAGE_LAYOUT_UNDEFINED,							// VkImageLayout				initialLayout;
 			VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL			// VkImageLayout				finalLayout
 		};
 
@@ -3234,7 +3235,7 @@
 		VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,			// VkStructureType			sType;
 		DE_NULL,										// const void*				pNext;
 		0u,												// VkAccessFlags			srcAccessMask;
-		0u,												// VkAccessFlags			dstAccessMask;
+		VK_ACCESS_TRANSFER_WRITE_BIT,					// VkAccessFlags			dstAccessMask;
 		VK_IMAGE_LAYOUT_UNDEFINED,						// VkImageLayout			oldLayout;
 		VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,			// VkImageLayout			newLayout;
 		VK_QUEUE_FAMILY_IGNORED,						// deUint32					srcQueueFamilyIndex;
diff --git a/external/vulkancts/modules/vulkan/shaderrender/vktShaderRender.cpp b/external/vulkancts/modules/vulkan/shaderrender/vktShaderRender.cpp
index 07a1a97..37d526b 100644
--- a/external/vulkancts/modules/vulkan/shaderrender/vktShaderRender.cpp
+++ b/external/vulkancts/modules/vulkan/shaderrender/vktShaderRender.cpp
@@ -1552,9 +1552,7 @@
 			}
 
 			const SamplerUniform*		sampler			= static_cast<const SamplerUniform*>(uniformInfo);
-
-			const VkAccessFlags			outputMask		= VK_ACCESS_HOST_WRITE_BIT | VK_ACCESS_TRANSFER_WRITE_BIT;
-			const VkImageMemoryBarrier	textureBarrier	= createImageMemoryBarrier(sampler->image->get(), outputMask, 0u, VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL);
+			const VkImageMemoryBarrier	textureBarrier	= createImageMemoryBarrier(sampler->image->get(), 0u, VK_ACCESS_SHADER_READ_BIT, VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL);
 
 			barriers.push_back(textureBarrier);
 		}
@@ -1690,7 +1688,7 @@
 		{
 			VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,		// VkStructureType			sType;
 			DE_NULL,									// const void*				pNext;
-			VK_ACCESS_TRANSFER_WRITE_BIT,				// VkAccessFlags			srcAccessMask;
+			VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT,		// VkAccessFlags			srcAccessMask;
 			VK_ACCESS_TRANSFER_READ_BIT,				// VkAccessFlags			dstAccessMask;
 			VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,	// VkImageLayout			oldLayout;
 			VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,		// VkImageLayout			newLayout;
diff --git a/external/vulkancts/modules/vulkan/ssbo/vktSSBOLayoutCase.cpp b/external/vulkancts/modules/vulkan/ssbo/vktSSBOLayoutCase.cpp
index ed1ca88..ca02de0 100644
--- a/external/vulkancts/modules/vulkan/ssbo/vktSSBOLayoutCase.cpp
+++ b/external/vulkancts/modules/vulkan/ssbo/vktSSBOLayoutCase.cpp
@@ -1925,9 +1925,6 @@
 				m_uniformBuffers.push_back(VkBufferSp(new vk::Unique<vk::VkBuffer>(buffer)));
 				m_uniformAllocs.push_back(AllocationSp(alloc.release()));
 			}
-
-			setUpdateBuilder.writeArray(*descriptorSet, vk::DescriptorSetUpdateBuilder::Location::binding(1),
-										vk::VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, numBlocks, &descriptors[0]);
 		}
 		else
 		{
@@ -1963,13 +1960,25 @@
 				descriptors[blockNdx] = makeDescriptorBufferInfo(*buffer, offset, bufferSize);
 			}
 
-			setUpdateBuilder.writeArray(*descriptorSet, vk::DescriptorSetUpdateBuilder::Location::binding(1),
-										vk::VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, numBlocks, &descriptors[0]);
-
 			m_uniformBuffers.push_back(VkBufferSp(new vk::Unique<vk::VkBuffer>(buffer)));
 			m_uniformAllocs.push_back(AllocationSp(alloc.release()));
 		}
 
+		// Update remaining bindings
+		{
+			int blockNdx = 0;
+			for (int bindingNdx = 0; bindingNdx < numBindings; ++bindingNdx)
+			{
+				const BufferBlock&	block				= m_interface.getBlock(bindingNdx);
+				const int			numBlocksInBinding	= (block.isArray() ? block.getArraySize() : 1);
+
+				setUpdateBuilder.writeArray(*descriptorSet, vk::DescriptorSetUpdateBuilder::Location::binding(bindingNdx + 1),
+					vk::VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, numBlocksInBinding, &descriptors[blockNdx]);
+
+				blockNdx += numBlocksInBinding;
+			}
+		}
+
 		// Copy the initial data to the storage buffers
 		{
 			mappedBlockPtrs = blockLocationsToPtrs(m_refLayout, blockLocations, mapPtrs);
diff --git a/external/vulkancts/modules/vulkan/vktRenderPassTests.cpp b/external/vulkancts/modules/vulkan/vktRenderPassTests.cpp
index 3bb7a74..556dd6f 100644
--- a/external/vulkancts/modules/vulkan/vktRenderPassTests.cpp
+++ b/external/vulkancts/modules/vulkan/vktRenderPassTests.cpp
@@ -372,6 +372,23 @@
 		   | VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT;
 }
 
+VkAccessFlags getMemoryFlagsForLayout (const VkImageLayout layout)
+{
+	switch (layout)
+	{
+		case VK_IMAGE_LAYOUT_GENERAL:							return getAllMemoryReadFlags() | getAllMemoryWriteFlags();
+		case VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL:			return VK_ACCESS_COLOR_ATTACHMENT_READ_BIT | VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT;
+		case VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL:	return VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT | VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT;
+		case VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL:	return VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT;
+		case VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL:			return VK_ACCESS_SHADER_READ_BIT;
+		case VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL:				return VK_ACCESS_TRANSFER_READ_BIT;
+		case VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL:				return VK_ACCESS_TRANSFER_WRITE_BIT;
+
+		default:
+			return (VkAccessFlags)0;
+	}
+}
+
 VkPipelineStageFlags getAllPipelineStageFlags (void)
 {
 	return VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT
@@ -1658,7 +1675,7 @@
 			STENCIL_VALUE											// stencilReference
 		},															// back
 
-		-1.0f,														// minDepthBounds;
+		0.0f,														// minDepthBounds;
 		1.0f														// maxDepthBounds;
 	};
 	const VkPipelineColorBlendStateCreateInfo blendState =
@@ -1861,25 +1878,25 @@
 
 			const VkImageMemoryBarrier barrier =
 			{
-				VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,								// sType;
-				DE_NULL,															// pNext;
+				VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,							// sType;
+				DE_NULL,														// pNext;
 
-				getAllMemoryWriteFlags(),											// srcAccessMask
-				getAllMemoryReadFlags(),											// dstAccessMask
+				(VkAccessFlags)0,												// srcAccessMask
+				getAllMemoryReadFlags() | VK_ACCESS_TRANSFER_WRITE_BIT,			// dstAccessMask
 
-				VK_IMAGE_LAYOUT_UNDEFINED,											// oldLayout
-				VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,								// newLayout;
+				VK_IMAGE_LAYOUT_UNDEFINED,										// oldLayout
+				VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,							// newLayout;
 
-				queueIndex,															// srcQueueFamilyIndex;
-				queueIndex,															// destQueueFamilyIndex;
+				queueIndex,														// srcQueueFamilyIndex;
+				queueIndex,														// destQueueFamilyIndex;
 
-				attachmentResources[attachmentNdx]->getImage(),						// image;
-				{																	// subresourceRange;
-					getImageAspectFlags(attachmentInfo[attachmentNdx].getFormat()),	// aspect;
-					0,																// baseMipLevel;
-					1,																// mipLevels;
-					0,																// baseArraySlice;
-					1																// arraySize;
+				attachmentResources[attachmentNdx]->getImage(),					// image;
+				{																// subresourceRange;
+					getImageAspectFlags(attachmentInfo[attachmentNdx].getFormat()),		// aspect;
+					0,																	// baseMipLevel;
+					1,																	// mipLevels;
+					0,																	// baseArraySlice;
+					1																	// arraySize;
 				}
 			};
 
@@ -1944,30 +1961,28 @@
 
 		for (size_t attachmentNdx = 0; attachmentNdx < attachmentInfo.size(); attachmentNdx++)
 		{
-			const VkImageMemoryBarrier barrier =
+			const VkImageLayout			oldLayout = clearValues[attachmentNdx] ? VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL : VK_IMAGE_LAYOUT_UNDEFINED;
+			const VkImageMemoryBarrier	barrier   =
 			{
-				VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,								// sType;
-				DE_NULL,															// pNext;
+				VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,					// sType;
+				DE_NULL,												// pNext;
 
-				getAllMemoryWriteFlags(),											// srcAccessMask
-				getAllMemoryReadFlags(),											// dstAccessMask
+				(oldLayout != VK_IMAGE_LAYOUT_UNDEFINED ? getAllMemoryWriteFlags() : (VkAccessFlags)0),					// srcAccessMask
+				getAllMemoryReadFlags() | getMemoryFlagsForLayout(attachmentInfo[attachmentNdx].getInitialLayout()),	// dstAccessMask
 
-				clearValues[attachmentNdx] ?
-					VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL
-					: VK_IMAGE_LAYOUT_UNDEFINED,									// oldLayout
+				oldLayout,												// oldLayout
+				attachmentInfo[attachmentNdx].getInitialLayout(),		// newLayout;
 
-				attachmentInfo[attachmentNdx].getInitialLayout(),					// newLayout;
+				queueIndex,												// srcQueueFamilyIndex;
+				queueIndex,												// destQueueFamilyIndex;
 
-				queueIndex,															// srcQueueFamilyIndex;
-				queueIndex,															// destQueueFamilyIndex;
-
-				attachmentResources[attachmentNdx]->getImage(),						// image;
-				{																	// subresourceRange;
-					getImageAspectFlags(attachmentInfo[attachmentNdx].getFormat()),	// aspect;
-					0,																// baseMipLevel;
-					1,																// mipLevels;
-					0,																// baseArraySlice;
-					1																// arraySize;
+				attachmentResources[attachmentNdx]->getImage(),			// image;
+				{														// subresourceRange;
+					getImageAspectFlags(attachmentInfo[attachmentNdx].getFormat()),		// aspect;
+					0,																	// baseMipLevel;
+					1,																	// mipLevels;
+					0,																	// baseArraySlice;
+					1																	// arraySize;
 				}
 			};
 
@@ -2058,27 +2073,28 @@
 			if (isLazy[attachmentNdx])
 				continue;
 
-			const VkImageMemoryBarrier barrier =
+			const VkImageLayout			oldLayout	= attachmentInfo[attachmentNdx].getFinalLayout();
+			const VkImageMemoryBarrier	barrier		=
 			{
-				VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,				// sType
-				DE_NULL,											// pNext
+				VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,							// sType
+				DE_NULL,														// pNext
 
-				getAllMemoryWriteFlags(),							// srcAccessMask
-				getAllMemoryReadFlags(),							// dstAccessMask
+				getAllMemoryWriteFlags() | getMemoryFlagsForLayout(oldLayout),	// srcAccessMask
+				getAllMemoryReadFlags(),										// dstAccessMask
 
-				attachmentInfo[attachmentNdx].getFinalLayout(),		// oldLayout
-				VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,				// newLayout
+				oldLayout,														// oldLayout
+				VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,							// newLayout
 
-				queueIndex,											// srcQueueFamilyIndex
-				queueIndex,											// destQueueFamilyIndex
+				queueIndex,														// srcQueueFamilyIndex
+				queueIndex,														// destQueueFamilyIndex
 
-				attachmentResources[attachmentNdx]->getImage(),		// image
-				{													// subresourceRange
-					getImageAspectFlags(attachmentInfo[attachmentNdx].getFormat()),	// aspect;
-					0,										// baseMipLevel
-					1,										// mipLevels
-					0,										// baseArraySlice
-					1										// arraySize
+				attachmentResources[attachmentNdx]->getImage(),					// image
+				{																// subresourceRange
+					getImageAspectFlags(attachmentInfo[attachmentNdx].getFormat()),		// aspect;
+					0,																	// baseMipLevel
+					1,																	// mipLevels
+					0,																	// baseArraySlice
+					1																	// arraySize
 				}
 			};
 
@@ -2186,8 +2202,6 @@
 
 				bufferBarriers.push_back(secondaryBufferBarrier);
 			}
-
-			bufferBarriers.push_back(bufferBarrier);
 		}
 
 		if (!bufferBarriers.empty())
diff --git a/external/vulkancts/modules/vulkan/vktShaderLibrary.cpp b/external/vulkancts/modules/vulkan/vktShaderLibrary.cpp
index 24b22a1..37a5b59 100644
--- a/external/vulkancts/modules/vulkan/vktShaderLibrary.cpp
+++ b/external/vulkancts/modules/vulkan/vktShaderLibrary.cpp
@@ -135,7 +135,7 @@
 DataType getTransportType (DataType valueType)
 {
 	if (isDataTypeBoolOrBVec(valueType))
-		return glu::getDataTypeIntVec(getDataTypeScalarSize(valueType));
+		return glu::getDataTypeUintVec(getDataTypeScalarSize(valueType));
 	else
 		return valueType;
 }
@@ -1162,7 +1162,7 @@
 		vk::VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO,		// sType
 		DE_NULL,															// pNext
 		(vk::VkPipelineVertexInputStateCreateFlags)0,
-		DE_LENGTH_OF_ARRAY(vertexBindings),									// bindingCount
+		(inputValues.empty() ? 1u : 2u),									// bindingCount
 		vertexBindings,														// pVertexBindingDescriptions
 		(deUint32)vertexAttribParams.size(),								// attributeCount
 		&vertexAttribParams[0],												// pVertexAttributeDescriptions
@@ -1540,8 +1540,10 @@
 		vkd.cmdBeginRenderPass(*m_cmdBuffer, &passBeginInfo, vk::VK_SUBPASS_CONTENTS_INLINE);
 	}
 
-	vkd.cmdBindPipeline			(*m_cmdBuffer, vk::VK_PIPELINE_BIND_POINT_GRAPHICS, *m_pipeline);
-	vkd.cmdBindDescriptorSets	(*m_cmdBuffer, vk::VK_PIPELINE_BIND_POINT_GRAPHICS, *m_pipelineLayout, 0u, 1u, &*m_descriptorSet, 0u, DE_NULL);
+	vkd.cmdBindPipeline(*m_cmdBuffer, vk::VK_PIPELINE_BIND_POINT_GRAPHICS, *m_pipeline);
+
+	if (!m_spec.values.uniforms.empty() || !m_spec.values.outputs.empty())
+		vkd.cmdBindDescriptorSets(*m_cmdBuffer, vk::VK_PIPELINE_BIND_POINT_GRAPHICS, *m_pipelineLayout, 0u, 1u, &*m_descriptorSet, 0u, DE_NULL);
 
 	{
 		const vk::VkBuffer		buffers[]	= { *m_posNdxBuffer, *m_inputBuffer };
diff --git a/external/vulkancts/mustpass/1.0.0/vk-default.txt b/external/vulkancts/mustpass/1.0.0/vk-default.txt
index 8c89acc..b6867e3 100644
--- a/external/vulkancts/mustpass/1.0.0/vk-default.txt
+++ b/external/vulkancts/mustpass/1.0.0/vk-default.txt
@@ -63273,7 +63273,6 @@
 dEQP-VK.glsl.functions.misc.argument_eval_order_1_fragment
 dEQP-VK.glsl.functions.misc.argument_eval_order_2_vertex
 dEQP-VK.glsl.functions.misc.argument_eval_order_2_fragment
-dEQP-VK.glsl.linkage.varying.rules.fragment_declare
 dEQP-VK.glsl.linkage.varying.rules.vertex_declare
 dEQP-VK.glsl.linkage.varying.rules.both_declare
 dEQP-VK.glsl.linkage.varying.rules.vertex_declare_fragment_use
diff --git a/framework/delibs/debase/deString.c b/framework/delibs/debase/deString.c
index f53657d..e6290f0 100644
--- a/framework/delibs/debase/deString.c
+++ b/framework/delibs/debase/deString.c
@@ -111,7 +111,6 @@
 	return DE_TRUE;
 }
 
-
 int deVsprintf (char* string, size_t size, const char* format, va_list list)
 {
 	int			res;
@@ -180,4 +179,16 @@
 #endif
 }
 
+size_t deStrnlen (const char* string, size_t maxSize)
+{
+#if ((DE_COMPILER == DE_COMPILER_MSC) && (DE_OS != DE_OS_WINCE)) || (defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 201100L))
+	return strnlen_s(string, maxSize);
+#else
+	size_t len = 0;
+	while (len < maxSize || string[len] != 0)
+		++len;
+	return len;
+#endif
+}
+
 DE_END_EXTERN_C
diff --git a/framework/delibs/debase/deString.h b/framework/delibs/debase/deString.h
index 52e232a..cd45465 100644
--- a/framework/delibs/debase/deString.h
+++ b/framework/delibs/debase/deString.h
@@ -43,6 +43,7 @@
 deInt32		deSprintf				(char* string, size_t size, const char* format, ...) DE_PRINTF_FUNC_ATTR(3, 4);
 char*		deStrcpy				(char* dst, size_t size, const char* src);
 char*		deStrcat				(char* s1, size_t size, const char* s2);
+size_t		deStrnlen				(const char* string, size_t maxSize);
 
 DE_END_EXTERN_C