diff --git a/src/Pipeline/SpirvShader.cpp b/src/Pipeline/SpirvShader.cpp
index 972ec15..2973cdd 100644
--- a/src/Pipeline/SpirvShader.cpp
+++ b/src/Pipeline/SpirvShader.cpp
@@ -1260,54 +1260,54 @@
 	}
 }
 
-SIMD::Pointer SpirvShader::WalkExplicitLayoutAccessChain(Object::ID baseId, Object::ID elementId, const Span &indexIds, bool nonUniform, const EmitState *state) const
+SIMD::Pointer SpirvShader::EmitState::WalkExplicitLayoutAccessChain(Object::ID baseId, Object::ID elementId, const Span &indexIds, bool nonUniform) const
 {
 	// Produce a offset into external memory in sizeof(float) units
 
-	auto &baseObject = getObject(baseId);
-	Type::ID typeId = getType(baseObject).element;
-	Decorations d = GetDecorationsForId(baseObject.typeId());
+	auto &baseObject = shader.getObject(baseId);
+	Type::ID typeId = shader.getType(baseObject).element;
+	Decorations d = shader.GetDecorationsForId(baseObject.typeId());
 	SIMD::Int arrayIndex = 0;
 
 	uint32_t start = 0;
 	if(baseObject.kind == Object::Kind::DescriptorSet)
 	{
-		auto type = getType(typeId).definition.opcode();
+		auto type = shader.getType(typeId).definition.opcode();
 		if(type == spv::OpTypeArray || type == spv::OpTypeRuntimeArray)
 		{
-			auto &obj = getObject(indexIds[0]);
+			auto &obj = shader.getObject(indexIds[0]);
 			ASSERT(obj.kind == Object::Kind::Constant || obj.kind == Object::Kind::Intermediate);
 			if(obj.kind == Object::Kind::Constant)
 			{
-				arrayIndex = GetConstScalarInt(indexIds[0]);
+				arrayIndex = shader.GetConstScalarInt(indexIds[0]);
 			}
 			else
 			{
-				nonUniform |= GetDecorationsForId(indexIds[0]).NonUniform;
-				arrayIndex = state->getIntermediate(indexIds[0]).Int(0);
+				nonUniform |= shader.GetDecorationsForId(indexIds[0]).NonUniform;
+				arrayIndex = getIntermediate(indexIds[0]).Int(0);
 			}
 
 			start = 1;
-			typeId = getType(typeId).element;
+			typeId = shader.getType(typeId).element;
 		}
 	}
 
-	auto ptr = GetPointerToData(baseId, arrayIndex, nonUniform, state);
-	OffsetToElement(ptr, elementId, d.ArrayStride, state);
+	auto ptr = GetPointerToData(baseId, arrayIndex, nonUniform);
+	OffsetToElement(ptr, elementId, d.ArrayStride);
 
 	int constantOffset = 0;
 
 	for(uint32_t i = start; i < indexIds.size(); i++)
 	{
-		auto &type = getType(typeId);
-		ApplyDecorationsForId(&d, typeId);
+		auto &type = shader.getType(typeId);
+		shader.ApplyDecorationsForId(&d, typeId);
 
 		switch(type.definition.opcode())
 		{
 		case spv::OpTypeStruct:
 			{
-				int memberIndex = GetConstScalarInt(indexIds[i]);
-				ApplyDecorationsForIdMember(&d, typeId, memberIndex);
+				int memberIndex = shader.GetConstScalarInt(indexIds[i]);
+				shader.ApplyDecorationsForIdMember(&d, typeId, memberIndex);
 				ASSERT(d.HasOffset);
 				constantOffset += d.Offset;
 				typeId = type.definition.word(2u + memberIndex);
@@ -1318,14 +1318,14 @@
 			{
 				// TODO: b/127950082: Check bounds.
 				ASSERT(d.HasArrayStride);
-				auto &obj = getObject(indexIds[i]);
+				auto &obj = shader.getObject(indexIds[i]);
 				if(obj.kind == Object::Kind::Constant)
 				{
-					constantOffset += d.ArrayStride * GetConstScalarInt(indexIds[i]);
+					constantOffset += d.ArrayStride * shader.GetConstScalarInt(indexIds[i]);
 				}
 				else
 				{
-					ptr += SIMD::Int(d.ArrayStride) * state->getIntermediate(indexIds[i]).Int(0);
+					ptr += SIMD::Int(d.ArrayStride) * getIntermediate(indexIds[i]).Int(0);
 				}
 				typeId = type.element;
 			}
@@ -1336,14 +1336,14 @@
 				ASSERT(d.HasMatrixStride);
 				d.InsideMatrix = true;
 				auto columnStride = (d.HasRowMajor && d.RowMajor) ? static_cast<int32_t>(sizeof(float)) : d.MatrixStride;
-				auto &obj = getObject(indexIds[i]);
+				auto &obj = shader.getObject(indexIds[i]);
 				if(obj.kind == Object::Kind::Constant)
 				{
-					constantOffset += columnStride * GetConstScalarInt(indexIds[i]);
+					constantOffset += columnStride * shader.GetConstScalarInt(indexIds[i]);
 				}
 				else
 				{
-					ptr += SIMD::Int(columnStride) * state->getIntermediate(indexIds[i]).Int(0);
+					ptr += SIMD::Int(columnStride) * getIntermediate(indexIds[i]).Int(0);
 				}
 				typeId = type.element;
 			}
@@ -1351,14 +1351,14 @@
 		case spv::OpTypeVector:
 			{
 				auto elemStride = (d.InsideMatrix && d.HasRowMajor && d.RowMajor) ? d.MatrixStride : static_cast<int32_t>(sizeof(float));
-				auto &obj = getObject(indexIds[i]);
+				auto &obj = shader.getObject(indexIds[i]);
 				if(obj.kind == Object::Kind::Constant)
 				{
-					constantOffset += elemStride * GetConstScalarInt(indexIds[i]);
+					constantOffset += elemStride * shader.GetConstScalarInt(indexIds[i]);
 				}
 				else
 				{
-					ptr += SIMD::Int(elemStride) * state->getIntermediate(indexIds[i]).Int(0);
+					ptr += SIMD::Int(elemStride) * getIntermediate(indexIds[i]).Int(0);
 				}
 				typeId = type.element;
 			}
@@ -1372,34 +1372,33 @@
 	return ptr;
 }
 
-SIMD::Pointer SpirvShader::WalkAccessChain(Object::ID baseId, Object::ID elementId, const Span &indexIds, bool nonUniform, const EmitState *state) const
+SIMD::Pointer SpirvShader::EmitState::WalkAccessChain(Object::ID baseId, Object::ID elementId, const Span &indexIds, bool nonUniform) const
 {
 	// TODO: avoid doing per-lane work in some cases if we can?
-	auto routine = state->routine;
-	auto &baseObject = getObject(baseId);
-	Type::ID typeId = getType(baseObject).element;
-	Decorations d = GetDecorationsForId(baseObject.typeId());
-	auto storageClass = getType(baseObject).storageClass;
+	auto &baseObject = shader.getObject(baseId);
+	Type::ID typeId = shader.getType(baseObject).element;
+	Decorations d = shader.GetDecorationsForId(baseObject.typeId());
+	auto storageClass = shader.getType(baseObject).storageClass;
 	bool interleavedByLane = IsStorageInterleavedByLane(storageClass);
 
-	auto ptr = state->getPointer(baseId);
-	OffsetToElement(ptr, elementId, d.ArrayStride, state);
+	auto ptr = getPointer(baseId);
+	OffsetToElement(ptr, elementId, d.ArrayStride);
 
 	int constantOffset = 0;
 
 	for(uint32_t i = 0; i < indexIds.size(); i++)
 	{
-		auto &type = getType(typeId);
+		auto &type = shader.getType(typeId);
 		switch(type.opcode())
 		{
 		case spv::OpTypeStruct:
 			{
-				int memberIndex = GetConstScalarInt(indexIds[i]);
+				int memberIndex = shader.GetConstScalarInt(indexIds[i]);
 				int offsetIntoStruct = 0;
 				for(auto j = 0; j < memberIndex; j++)
 				{
 					auto memberType = type.definition.word(2u + j);
-					offsetIntoStruct += getType(memberType).componentCount * sizeof(float);
+					offsetIntoStruct += shader.getType(memberType).componentCount * sizeof(float);
 				}
 				constantOffset += offsetIntoStruct;
 				typeId = type.definition.word(2u + memberIndex);
@@ -1415,20 +1414,20 @@
 				if(storageClass == spv::StorageClassUniformConstant)
 				{
 					// indexing into an array of descriptors.
-					auto d = descriptorDecorations.at(baseId);
+					auto d = shader.descriptorDecorations.at(baseId);
 					ASSERT(d.DescriptorSet >= 0);
 					ASSERT(d.Binding >= 0);
 					uint32_t descriptorSize = routine->pipelineLayout->getDescriptorSize(d.DescriptorSet, d.Binding);
 
-					auto &obj = getObject(indexIds[i]);
+					auto &obj = shader.getObject(indexIds[i]);
 					if(obj.kind == Object::Kind::Constant)
 					{
-						ptr += descriptorSize * GetConstScalarInt(indexIds[i]);
+						ptr += descriptorSize * shader.GetConstScalarInt(indexIds[i]);
 					}
 					else
 					{
-						nonUniform |= GetDecorationsForId(indexIds[i]).NonUniform;
-						SIMD::Int intermediate = state->getIntermediate(indexIds[i]).Int(0);
+						nonUniform |= shader.GetDecorationsForId(indexIds[i]).NonUniform;
+						SIMD::Int intermediate = getIntermediate(indexIds[i]).Int(0);
 						if(nonUniform)
 						{
 							// NonUniform array data can deal with pointers not bound by a 32-bit address
@@ -1450,20 +1449,20 @@
 				}
 				else
 				{
-					auto stride = getType(type.element).componentCount * static_cast<uint32_t>(sizeof(float));
+					auto stride = shader.getType(type.element).componentCount * static_cast<uint32_t>(sizeof(float));
 
 					if(interleavedByLane)
 					{
 						stride *= SIMD::Width;
 					}
 
-					if(getObject(indexIds[i]).kind == Object::Kind::Constant)
+					if(shader.getObject(indexIds[i]).kind == Object::Kind::Constant)
 					{
-						ptr += stride * GetConstScalarInt(indexIds[i]);
+						ptr += stride * shader.GetConstScalarInt(indexIds[i]);
 					}
 					else
 					{
-						ptr += SIMD::Int(stride) * state->getIntermediate(indexIds[i]).Int(0);
+						ptr += SIMD::Int(stride) * getIntermediate(indexIds[i]).Int(0);
 					}
 				}
 				typeId = type.element;
@@ -1717,7 +1716,7 @@
 	object.definition = insn;
 }
 
-OutOfBoundsBehavior SpirvShader::getOutOfBoundsBehavior(Object::ID pointerId, const EmitState *state) const
+OutOfBoundsBehavior SpirvShader::getOutOfBoundsBehavior(Object::ID pointerId, const vk::PipelineLayout *pipelineLayout) const
 {
 	auto it = descriptorDecorations.find(pointerId);
 	if(it != descriptorDecorations.end())
@@ -1725,7 +1724,7 @@
 		const auto &d = it->second;
 		if((d.DescriptorSet >= 0) && (d.Binding >= 0))
 		{
-			auto descriptorType = state->routine->pipelineLayout->getDescriptorType(d.DescriptorSet, d.Binding);
+			auto descriptorType = pipelineLayout->getDescriptorType(d.DescriptorSet, d.Binding);
 			if(descriptorType == VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK_EXT)
 			{
 				return OutOfBoundsBehavior::UndefinedBehavior;
@@ -1825,7 +1824,7 @@
 
 void SpirvShader::emit(SpirvRoutine *routine, const RValue<SIMD::Int> &activeLaneMask, const RValue<SIMD::Int> &storesAndAtomicsMask, const vk::DescriptorSet::Bindings &descriptorSets, unsigned int multiSampleCount) const
 {
-	EmitState state(routine, entryPoint, activeLaneMask, storesAndAtomicsMask, descriptorSets, multiSampleCount);
+	EmitState state(*this, routine, entryPoint, activeLaneMask, storesAndAtomicsMask, descriptorSets, multiSampleCount);
 
 	// Emit everything up to the first label
 	// TODO: Separate out dispatch of block from non-block instructions?
@@ -1835,32 +1834,32 @@
 		{
 			break;
 		}
-		EmitInstruction(insn, &state);
+		state.EmitInstruction(insn);
 	}
 
 	// Emit all the blocks starting from entryPoint.
-	EmitBlocks(getFunction(entryPoint).entry, &state);
+	state.EmitBlocks(getFunction(entryPoint).entry);
 }
 
-void SpirvShader::EmitInstructions(InsnIterator begin, InsnIterator end, EmitState *state) const
+void SpirvShader::EmitState::EmitInstructions(InsnIterator begin, InsnIterator end)
 {
 	for(auto insn = begin; insn != end; insn++)
 	{
-		auto res = EmitInstruction(insn, state);
-		switch(res)
+		auto result = EmitInstruction(insn);
+		switch(result)
 		{
 		case EmitResult::Continue:
 			continue;
 		case EmitResult::Terminator:
 			break;
 		default:
-			UNREACHABLE("Unexpected EmitResult %d", int(res));
+			UNREACHABLE("Unexpected EmitResult %d", int(result));
 			break;
 		}
 	}
 }
 
-SpirvShader::EmitResult SpirvShader::EmitInstruction(InsnIterator insn, EmitState *state) const
+SpirvShader::EmitResult SpirvShader::EmitState::EmitInstruction(InsnIterator insn)
 {
 	auto opcode = insn.opcode();
 
@@ -1941,15 +1940,15 @@
 		return EmitResult::Continue;
 
 	case spv::OpVariable:
-		return EmitVariable(insn, state);
+		return EmitVariable(insn);
 
 	case spv::OpLoad:
 	case spv::OpAtomicLoad:
-		return EmitLoad(insn, state);
+		return EmitLoad(insn);
 
 	case spv::OpStore:
 	case spv::OpAtomicStore:
-		return EmitStore(insn, state);
+		return EmitStore(insn);
 
 	case spv::OpAtomicIAdd:
 	case spv::OpAtomicISub:
@@ -1963,52 +1962,52 @@
 	case spv::OpAtomicIIncrement:
 	case spv::OpAtomicIDecrement:
 	case spv::OpAtomicExchange:
-		return EmitAtomicOp(insn, state);
+		return EmitAtomicOp(insn);
 
 	case spv::OpAtomicCompareExchange:
-		return EmitAtomicCompareExchange(insn, state);
+		return EmitAtomicCompareExchange(insn);
 
 	case spv::OpAccessChain:
 	case spv::OpInBoundsAccessChain:
 	case spv::OpPtrAccessChain:
-		return EmitAccessChain(insn, state);
+		return EmitAccessChain(insn);
 
 	case spv::OpCompositeConstruct:
-		return EmitCompositeConstruct(insn, state);
+		return EmitCompositeConstruct(insn);
 
 	case spv::OpCompositeInsert:
-		return EmitCompositeInsert(insn, state);
+		return EmitCompositeInsert(insn);
 
 	case spv::OpCompositeExtract:
-		return EmitCompositeExtract(insn, state);
+		return EmitCompositeExtract(insn);
 
 	case spv::OpVectorShuffle:
-		return EmitVectorShuffle(insn, state);
+		return EmitVectorShuffle(insn);
 
 	case spv::OpVectorExtractDynamic:
-		return EmitVectorExtractDynamic(insn, state);
+		return EmitVectorExtractDynamic(insn);
 
 	case spv::OpVectorInsertDynamic:
-		return EmitVectorInsertDynamic(insn, state);
+		return EmitVectorInsertDynamic(insn);
 
 	case spv::OpVectorTimesScalar:
 	case spv::OpMatrixTimesScalar:
-		return EmitVectorTimesScalar(insn, state);
+		return EmitVectorTimesScalar(insn);
 
 	case spv::OpMatrixTimesVector:
-		return EmitMatrixTimesVector(insn, state);
+		return EmitMatrixTimesVector(insn);
 
 	case spv::OpVectorTimesMatrix:
-		return EmitVectorTimesMatrix(insn, state);
+		return EmitVectorTimesMatrix(insn);
 
 	case spv::OpMatrixTimesMatrix:
-		return EmitMatrixTimesMatrix(insn, state);
+		return EmitMatrixTimesMatrix(insn);
 
 	case spv::OpOuterProduct:
-		return EmitOuterProduct(insn, state);
+		return EmitOuterProduct(insn);
 
 	case spv::OpTranspose:
-		return EmitTranspose(insn, state);
+		return EmitTranspose(insn);
 
 	case spv::OpNot:
 	case spv::OpBitFieldInsert:
@@ -2036,7 +2035,7 @@
 	case spv::OpDPdyFine:
 	case spv::OpFwidthFine:
 	case spv::OpQuantizeToF16:
-		return EmitUnaryOp(insn, state);
+		return EmitUnaryOp(insn);
 
 	case spv::OpIAdd:
 	case spv::OpISub:
@@ -2088,7 +2087,7 @@
 	case spv::OpSMulExtended:
 	case spv::OpIAddCarry:
 	case spv::OpISubBorrow:
-		return EmitBinaryOp(insn, state);
+		return EmitBinaryOp(insn);
 
 	case spv::OpDot:
 	case spv::OpSDot:
@@ -2097,54 +2096,54 @@
 	case spv::OpSDotAccSat:
 	case spv::OpUDotAccSat:
 	case spv::OpSUDotAccSat:
-		return EmitDot(insn, state);
+		return EmitDot(insn);
 
 	case spv::OpSelect:
-		return EmitSelect(insn, state);
+		return EmitSelect(insn);
 
 	case spv::OpExtInst:
-		return EmitExtendedInstruction(insn, state);
+		return EmitExtendedInstruction(insn);
 
 	case spv::OpAny:
-		return EmitAny(insn, state);
+		return EmitAny(insn);
 
 	case spv::OpAll:
-		return EmitAll(insn, state);
+		return EmitAll(insn);
 
 	case spv::OpBranch:
-		return EmitBranch(insn, state);
+		return EmitBranch(insn);
 
 	case spv::OpPhi:
-		return EmitPhi(insn, state);
+		return EmitPhi(insn);
 
 	case spv::OpSelectionMerge:
 	case spv::OpLoopMerge:
 		return EmitResult::Continue;
 
 	case spv::OpBranchConditional:
-		return EmitBranchConditional(insn, state);
+		return EmitBranchConditional(insn);
 
 	case spv::OpSwitch:
-		return EmitSwitch(insn, state);
+		return EmitSwitch(insn);
 
 	case spv::OpUnreachable:
-		return EmitUnreachable(insn, state);
+		return EmitUnreachable(insn);
 
 	case spv::OpReturn:
-		return EmitReturn(insn, state);
+		return EmitReturn(insn);
 
 	case spv::OpFunctionCall:
-		return EmitFunctionCall(insn, state);
+		return EmitFunctionCall(insn);
 
 	case spv::OpKill:
 	case spv::OpTerminateInvocation:
-		return EmitTerminateInvocation(insn, state);
+		return EmitTerminateInvocation(insn);
 
 	case spv::OpDemoteToHelperInvocation:
-		return EmitDemoteToHelperInvocation(insn, state);
+		return EmitDemoteToHelperInvocation(insn);
 
 	case spv::OpIsHelperInvocationEXT:
-		return EmitIsHelperInvocation(insn, state);
+		return EmitIsHelperInvocation(insn);
 
 	case spv::OpImageSampleImplicitLod:
 	case spv::OpImageSampleExplicitLod:
@@ -2158,47 +2157,47 @@
 	case spv::OpImageDrefGather:
 	case spv::OpImageFetch:
 	case spv::OpImageQueryLod:
-		return EmitImageSample(ImageInstruction(insn, *this, state), state);
+		return EmitImageSample(ImageInstruction(insn, shader, *this));
 
 	case spv::OpImageQuerySizeLod:
-		return EmitImageQuerySizeLod(insn, state);
+		return EmitImageQuerySizeLod(insn);
 
 	case spv::OpImageQuerySize:
-		return EmitImageQuerySize(insn, state);
+		return EmitImageQuerySize(insn);
 
 	case spv::OpImageQueryLevels:
-		return EmitImageQueryLevels(insn, state);
+		return EmitImageQueryLevels(insn);
 
 	case spv::OpImageQuerySamples:
-		return EmitImageQuerySamples(insn, state);
+		return EmitImageQuerySamples(insn);
 
 	case spv::OpImageRead:
-		return EmitImageRead(ImageInstruction(insn, *this, state), state);
+		return EmitImageRead(ImageInstruction(insn, shader, *this));
 
 	case spv::OpImageWrite:
-		return EmitImageWrite(ImageInstruction(insn, *this, state), state);
+		return EmitImageWrite(ImageInstruction(insn, shader, *this));
 
 	case spv::OpImageTexelPointer:
-		return EmitImageTexelPointer(ImageInstruction(insn, *this, state), state);
+		return EmitImageTexelPointer(ImageInstruction(insn, shader, *this));
 
 	case spv::OpSampledImage:
-		return EmitSampledImage(insn, state);
+		return EmitSampledImage(insn);
 
 	case spv::OpImage:
-		return EmitImage(insn, state);
+		return EmitImage(insn);
 
 	case spv::OpCopyObject:
 	case spv::OpCopyLogical:
-		return EmitCopyObject(insn, state);
+		return EmitCopyObject(insn);
 
 	case spv::OpCopyMemory:
-		return EmitCopyMemory(insn, state);
+		return EmitCopyMemory(insn);
 
 	case spv::OpControlBarrier:
-		return EmitControlBarrier(insn, state);
+		return EmitControlBarrier(insn);
 
 	case spv::OpMemoryBarrier:
-		return EmitMemoryBarrier(insn, state);
+		return EmitMemoryBarrier(insn);
 
 	case spv::OpGroupNonUniformElect:
 	case spv::OpGroupNonUniformAll:
@@ -2234,10 +2233,10 @@
 	case spv::OpGroupNonUniformLogicalAnd:
 	case spv::OpGroupNonUniformLogicalOr:
 	case spv::OpGroupNonUniformLogicalXor:
-		return EmitGroupNonUniform(insn, state);
+		return EmitGroupNonUniform(insn);
 
 	case spv::OpArrayLength:
-		return EmitArrayLength(insn, state);
+		return EmitArrayLength(insn);
 
 	default:
 		UNREACHABLE("%s", OpcodeName(opcode));
@@ -2247,27 +2246,27 @@
 	return EmitResult::Continue;
 }
 
-SpirvShader::EmitResult SpirvShader::EmitAccessChain(InsnIterator insn, EmitState *state) const
+SpirvShader::EmitResult SpirvShader::EmitState::EmitAccessChain(InsnIterator insn)
 {
 	Type::ID typeId = insn.word(1);
 	Object::ID resultId = insn.word(2);
-	bool nonUniform = GetDecorationsForId(resultId).NonUniform;
+	bool nonUniform = shader.GetDecorationsForId(resultId).NonUniform;
 	Object::ID baseId = insn.word(3);
-	auto &type = getType(typeId);
+	auto &type = shader.getType(typeId);
 	ASSERT(type.componentCount == 1);
-	ASSERT(getObject(resultId).kind == Object::Kind::Pointer);
+	ASSERT(shader.getObject(resultId).kind == Object::Kind::Pointer);
 
 	Object::ID elementId = (insn.opcode() == spv::OpPtrAccessChain) ? insn.word(4) : 0;
 	int indexId = (insn.opcode() == spv::OpPtrAccessChain) ? 5 : 4;
 	// TODO(b/236280746): Eliminate lookahead by optimizing inside SIMD::Pointer.
-	for(auto it = insn; it != end(); it++)
+	for(auto it = insn; it != shader.end(); it++)
 	{
 		if(it.opcode() == spv::OpLoad)
 		{
 			Object::ID pointerId = it.word(3);
 			if(pointerId.value() == resultId.value())
 			{
-				nonUniform |= GetDecorationsForId(it.word(2)).NonUniform;
+				nonUniform |= shader.GetDecorationsForId(it.word(2)).NonUniform;
 				break;
 			}
 		}
@@ -2278,30 +2277,30 @@
 	   type.storageClass == spv::StorageClassStorageBuffer ||
 	   type.storageClass == spv::StorageClassPhysicalStorageBuffer)
 	{
-		auto ptr = WalkExplicitLayoutAccessChain(baseId, elementId, Span(insn, indexId, insn.wordCount() - indexId), nonUniform, state);
-		state->createPointer(resultId, ptr);
+		auto ptr = WalkExplicitLayoutAccessChain(baseId, elementId, Span(insn, indexId, insn.wordCount() - indexId), nonUniform);
+		createPointer(resultId, ptr);
 	}
 	else
 	{
-		auto ptr = WalkAccessChain(baseId, elementId, Span(insn, indexId, insn.wordCount() - indexId), nonUniform, state);
-		state->createPointer(resultId, ptr);
+		auto ptr = WalkAccessChain(baseId, elementId, Span(insn, indexId, insn.wordCount() - indexId), nonUniform);
+		createPointer(resultId, ptr);
 	}
 
 	return EmitResult::Continue;
 }
 
-SpirvShader::EmitResult SpirvShader::EmitCompositeConstruct(InsnIterator insn, EmitState *state) const
+SpirvShader::EmitResult SpirvShader::EmitState::EmitCompositeConstruct(InsnIterator insn)
 {
-	auto &type = getType(insn.resultTypeId());
-	auto &dst = state->createIntermediate(insn.resultId(), type.componentCount);
+	auto &type = shader.getType(insn.resultTypeId());
+	auto &dst = createIntermediate(insn.resultId(), type.componentCount);
 	auto offset = 0u;
 
 	for(auto i = 0u; i < insn.wordCount() - 3; i++)
 	{
 		Object::ID srcObjectId = insn.word(3u + i);
-		auto &srcObject = getObject(srcObjectId);
-		auto &srcObjectTy = getType(srcObject);
-		Operand srcObjectAccess(this, state, srcObjectId);
+		auto &srcObject = shader.getObject(srcObjectId);
+		auto &srcObjectTy = shader.getType(srcObject);
+		Operand srcObjectAccess(shader, *this, srcObjectId);
 
 		for(auto j = 0u; j < srcObjectTy.componentCount; j++)
 		{
@@ -2312,17 +2311,17 @@
 	return EmitResult::Continue;
 }
 
-SpirvShader::EmitResult SpirvShader::EmitCompositeInsert(InsnIterator insn, EmitState *state) const
+SpirvShader::EmitResult SpirvShader::EmitState::EmitCompositeInsert(InsnIterator insn)
 {
 	Type::ID resultTypeId = insn.word(1);
-	auto &type = getType(resultTypeId);
-	auto &dst = state->createIntermediate(insn.resultId(), type.componentCount);
-	auto &newPartObject = getObject(insn.word(3));
-	auto &newPartObjectTy = getType(newPartObject);
-	auto firstNewComponent = WalkLiteralAccessChain(resultTypeId, Span(insn, 5, insn.wordCount() - 5));
+	auto &type = shader.getType(resultTypeId);
+	auto &dst = createIntermediate(insn.resultId(), type.componentCount);
+	auto &newPartObject = shader.getObject(insn.word(3));
+	auto &newPartObjectTy = shader.getType(newPartObject);
+	auto firstNewComponent = shader.WalkLiteralAccessChain(resultTypeId, Span(insn, 5, insn.wordCount() - 5));
 
-	Operand srcObjectAccess(this, state, insn.word(4));
-	Operand newPartObjectAccess(this, state, insn.word(3));
+	Operand srcObjectAccess(shader, *this, insn.word(4));
+	Operand newPartObjectAccess(shader, *this, insn.word(3));
 
 	// old components before
 	for(auto i = 0u; i < firstNewComponent; i++)
@@ -2343,15 +2342,15 @@
 	return EmitResult::Continue;
 }
 
-SpirvShader::EmitResult SpirvShader::EmitCompositeExtract(InsnIterator insn, EmitState *state) const
+SpirvShader::EmitResult SpirvShader::EmitState::EmitCompositeExtract(InsnIterator insn)
 {
-	auto &type = getType(insn.resultTypeId());
-	auto &dst = state->createIntermediate(insn.resultId(), type.componentCount);
-	auto &compositeObject = getObject(insn.word(3));
+	auto &type = shader.getType(insn.resultTypeId());
+	auto &dst = createIntermediate(insn.resultId(), type.componentCount);
+	auto &compositeObject = shader.getObject(insn.word(3));
 	Type::ID compositeTypeId = compositeObject.definition.word(1);
-	auto firstComponent = WalkLiteralAccessChain(compositeTypeId, Span(insn, 4, insn.wordCount() - 4));
+	auto firstComponent = shader.WalkLiteralAccessChain(compositeTypeId, Span(insn, 4, insn.wordCount() - 4));
 
-	Operand compositeObjectAccess(this, state, insn.word(3));
+	Operand compositeObjectAccess(shader, *this, insn.word(3));
 	for(auto i = 0u; i < type.componentCount; i++)
 	{
 		dst.move(i, compositeObjectAccess.Float(firstComponent + i));
@@ -2360,48 +2359,44 @@
 	return EmitResult::Continue;
 }
 
-SpirvShader::EmitResult SpirvShader::EmitVectorShuffle(InsnIterator insn, EmitState *state) const
+SpirvShader::EmitResult SpirvShader::EmitState::EmitVectorShuffle(InsnIterator insn)
 {
-	auto &type = getType(insn.resultTypeId());
-	auto &dst = state->createIntermediate(insn.resultId(), type.componentCount);
+	// Note: number of components in result, first vector, and second vector are all independent.
+	uint32_t resultSize = shader.getType(insn.resultTypeId()).componentCount;
+	uint32_t firstVectorSize = shader.getObjectType(insn.word(3)).componentCount;
 
-	// Note: number of components in result type, first half type, and second
-	// half type are all independent.
-	auto &firstHalfType = getObjectType(insn.word(3));
+	auto &result = createIntermediate(insn.resultId(), resultSize);
+	Operand firstVector(shader, *this, insn.word(3));
+	Operand secondVector(shader, *this, insn.word(4));
 
-	Operand firstHalfAccess(this, state, insn.word(3));
-	Operand secondHalfAccess(this, state, insn.word(4));
-
-	for(auto i = 0u; i < type.componentCount; i++)
+	for(uint32_t i = 0u; i < resultSize; i++)
 	{
-		auto selector = insn.word(5 + i);
-		if(selector == static_cast<uint32_t>(-1))
+		uint32_t selector = insn.word(5 + i);
+		if(selector == 0xFFFFFFFF)  // Undefined value.
 		{
-			// Undefined value. Until we decide to do real undef values, zero is as good
-			// a value as any
-			dst.move(i, RValue<SIMD::Float>(0.0f));
+			result.move(i, SIMD::Float());
 		}
-		else if(selector < firstHalfType.componentCount)
+		else if(selector < firstVectorSize)
 		{
-			dst.move(i, firstHalfAccess.Float(selector));
+			result.move(i, firstVector.Float(selector));
 		}
 		else
 		{
-			dst.move(i, secondHalfAccess.Float(selector - firstHalfType.componentCount));
+			result.move(i, secondVector.Float(selector - firstVectorSize));
 		}
 	}
 
 	return EmitResult::Continue;
 }
 
-SpirvShader::EmitResult SpirvShader::EmitVectorExtractDynamic(InsnIterator insn, EmitState *state) const
+SpirvShader::EmitResult SpirvShader::EmitState::EmitVectorExtractDynamic(InsnIterator insn)
 {
-	auto &type = getType(insn.resultTypeId());
-	auto &dst = state->createIntermediate(insn.resultId(), type.componentCount);
-	auto &srcType = getObjectType(insn.word(3));
+	auto &type = shader.getType(insn.resultTypeId());
+	auto &dst = createIntermediate(insn.resultId(), type.componentCount);
+	auto &srcType = shader.getObjectType(insn.word(3));
 
-	Operand src(this, state, insn.word(3));
-	Operand index(this, state, insn.word(4));
+	Operand src(shader, *this, insn.word(3));
+	Operand index(shader, *this, insn.word(4));
 
 	SIMD::UInt v = SIMD::UInt(0);
 
@@ -2414,14 +2409,14 @@
 	return EmitResult::Continue;
 }
 
-SpirvShader::EmitResult SpirvShader::EmitVectorInsertDynamic(InsnIterator insn, EmitState *state) const
+SpirvShader::EmitResult SpirvShader::EmitState::EmitVectorInsertDynamic(InsnIterator insn)
 {
-	auto &type = getType(insn.resultTypeId());
-	auto &dst = state->createIntermediate(insn.resultId(), type.componentCount);
+	auto &type = shader.getType(insn.resultTypeId());
+	auto &dst = createIntermediate(insn.resultId(), type.componentCount);
 
-	Operand src(this, state, insn.word(3));
-	Operand component(this, state, insn.word(4));
-	Operand index(this, state, insn.word(5));
+	Operand src(shader, *this, insn.word(3));
+	Operand component(shader, *this, insn.word(4));
+	Operand index(shader, *this, insn.word(5));
 
 	for(auto i = 0u; i < type.componentCount; i++)
 	{
@@ -2431,11 +2426,11 @@
 	return EmitResult::Continue;
 }
 
-SpirvShader::EmitResult SpirvShader::EmitSelect(InsnIterator insn, EmitState *state) const
+SpirvShader::EmitResult SpirvShader::EmitState::EmitSelect(InsnIterator insn)
 {
-	auto &type = getType(insn.resultTypeId());
-	auto result = getObject(insn.resultId());
-	auto cond = Operand(this, state, insn.word(3));
+	auto &type = shader.getType(insn.resultTypeId());
+	auto result = shader.getObject(insn.resultId());
+	auto cond = Operand(shader, *this, insn.word(3));
 	auto condIsScalar = (cond.componentCount == 1);
 
 	switch(result.kind)
@@ -2445,9 +2440,9 @@
 			ASSERT(condIsScalar);
 			ASSERT(type.storageClass == spv::StorageClassPhysicalStorageBuffer);
 
-			auto &lhs = state->getPointer(insn.word(4));
-			auto &rhs = state->getPointer(insn.word(5));
-			state->createPointer(insn.resultId(), SIMD::Pointer::IfThenElse(cond.Int(0), lhs, rhs));
+			auto &lhs = getPointer(insn.word(4));
+			auto &rhs = getPointer(insn.word(5));
+			createPointer(insn.resultId(), SIMD::Pointer::IfThenElse(cond.Int(0), lhs, rhs));
 
 			SPIRV_SHADER_DBG("{0}: {1}", insn.word(3), cond);
 			SPIRV_SHADER_DBG("{0}: {1}", insn.word(4), lhs);
@@ -2456,9 +2451,9 @@
 		break;
 	default:
 		{
-			auto lhs = Operand(this, state, insn.word(4));
-			auto rhs = Operand(this, state, insn.word(5));
-			auto &dst = state->createIntermediate(insn.resultId(), type.componentCount);
+			auto lhs = Operand(shader, *this, insn.word(4));
+			auto rhs = Operand(shader, *this, insn.word(5));
+			auto &dst = createIntermediate(insn.resultId(), type.componentCount);
 			for(auto i = 0u; i < type.componentCount; i++)
 			{
 				auto sel = cond.Int(condIsScalar ? 0 : i);
@@ -2476,13 +2471,13 @@
 	return EmitResult::Continue;
 }
 
-SpirvShader::EmitResult SpirvShader::EmitAny(InsnIterator insn, EmitState *state) const
+SpirvShader::EmitResult SpirvShader::EmitState::EmitAny(InsnIterator insn)
 {
-	auto &type = getType(insn.resultTypeId());
+	auto &type = shader.getType(insn.resultTypeId());
 	ASSERT(type.componentCount == 1);
-	auto &dst = state->createIntermediate(insn.resultId(), type.componentCount);
-	auto &srcType = getObjectType(insn.word(3));
-	auto src = Operand(this, state, insn.word(3));
+	auto &dst = createIntermediate(insn.resultId(), type.componentCount);
+	auto &srcType = shader.getObjectType(insn.word(3));
+	auto src = Operand(shader, *this, insn.word(3));
 
 	SIMD::UInt result = src.UInt(0);
 
@@ -2495,17 +2490,17 @@
 	return EmitResult::Continue;
 }
 
-SpirvShader::EmitResult SpirvShader::EmitAll(InsnIterator insn, EmitState *state) const
+SpirvShader::EmitResult SpirvShader::EmitState::EmitAll(InsnIterator insn)
 {
-	auto &type = getType(insn.resultTypeId());
+	auto &type = shader.getType(insn.resultTypeId());
 	ASSERT(type.componentCount == 1);
-	auto &dst = state->createIntermediate(insn.resultId(), type.componentCount);
-	auto &srcType = getObjectType(insn.word(3));
-	auto src = Operand(this, state, insn.word(3));
+	auto &dst = createIntermediate(insn.resultId(), type.componentCount);
+	auto &srcType = shader.getObjectType(insn.word(3));
+	auto src = Operand(shader, *this, insn.word(3));
 
 	SIMD::UInt result = src.UInt(0);
 
-	for(auto i = 1u; i < srcType.componentCount; i++)
+	for(uint32_t i = 1; i < srcType.componentCount; i++)
 	{
 		result &= src.UInt(i);
 	}
@@ -2514,22 +2509,22 @@
 	return EmitResult::Continue;
 }
 
-SpirvShader::EmitResult SpirvShader::EmitAtomicOp(InsnIterator insn, EmitState *state) const
+SpirvShader::EmitResult SpirvShader::EmitState::EmitAtomicOp(InsnIterator insn)
 {
-	auto &resultType = getType(Type::ID(insn.word(1)));
+	auto &resultType = shader.getType(Type::ID(insn.word(1)));
 	Object::ID resultId = insn.word(2);
 	Object::ID pointerId = insn.word(3);
 	Object::ID semanticsId = insn.word(5);
-	auto memorySemantics = static_cast<spv::MemorySemanticsMask>(getObject(semanticsId).constantValue[0]);
+	auto memorySemantics = static_cast<spv::MemorySemanticsMask>(shader.getObject(semanticsId).constantValue[0]);
 	auto memoryOrder = MemoryOrder(memorySemantics);
 	// Where no value is provided (increment/decrement) use an implicit value of 1.
-	auto value = (insn.wordCount() == 7) ? Operand(this, state, insn.word(6)).UInt(0) : RValue<SIMD::UInt>(1);
-	auto &dst = state->createIntermediate(resultId, resultType.componentCount);
-	auto ptr = state->getPointer(pointerId);
+	auto value = (insn.wordCount() == 7) ? Operand(shader, *this, insn.word(6)).UInt(0) : RValue<SIMD::UInt>(1);
+	auto &dst = createIntermediate(resultId, resultType.componentCount);
+	auto ptr = getPointer(pointerId);
 
-	SIMD::Int mask = state->activeLaneMask() & state->storesAndAtomicsMask();
+	SIMD::Int mask = activeLaneMask() & storesAndAtomicsMask();
 
-	if((getObject(pointerId).opcode() == spv::OpImageTexelPointer) && ptr.isBasePlusOffset)
+	if((shader.getObject(pointerId).opcode() == spv::OpImageTexelPointer) && ptr.isBasePlusOffset)
 	{
 		mask &= ptr.isInBounds(sizeof(int32_t), OutOfBoundsBehavior::Nullify);
 	}
@@ -2587,24 +2582,24 @@
 	return EmitResult::Continue;
 }
 
-SpirvShader::EmitResult SpirvShader::EmitAtomicCompareExchange(InsnIterator insn, EmitState *state) const
+SpirvShader::EmitResult SpirvShader::EmitState::EmitAtomicCompareExchange(InsnIterator insn)
 {
 	// Separate from EmitAtomicOp due to different instruction encoding
-	auto &resultType = getType(Type::ID(insn.word(1)));
+	auto &resultType = shader.getType(Type::ID(insn.word(1)));
 	Object::ID resultId = insn.word(2);
 
-	auto memorySemanticsEqual = static_cast<spv::MemorySemanticsMask>(getObject(insn.word(5)).constantValue[0]);
+	auto memorySemanticsEqual = static_cast<spv::MemorySemanticsMask>(shader.getObject(insn.word(5)).constantValue[0]);
 	auto memoryOrderEqual = MemoryOrder(memorySemanticsEqual);
-	auto memorySemanticsUnequal = static_cast<spv::MemorySemanticsMask>(getObject(insn.word(6)).constantValue[0]);
+	auto memorySemanticsUnequal = static_cast<spv::MemorySemanticsMask>(shader.getObject(insn.word(6)).constantValue[0]);
 	auto memoryOrderUnequal = MemoryOrder(memorySemanticsUnequal);
 
-	auto value = Operand(this, state, insn.word(7));
-	auto comparator = Operand(this, state, insn.word(8));
-	auto &dst = state->createIntermediate(resultId, resultType.componentCount);
-	auto ptr = state->getPointer(insn.word(3));
+	auto value = Operand(shader, *this, insn.word(7));
+	auto comparator = Operand(shader, *this, insn.word(8));
+	auto &dst = createIntermediate(resultId, resultType.componentCount);
+	auto ptr = getPointer(insn.word(3));
 
 	SIMD::UInt x(0);
-	auto mask = state->activeLaneMask() & state->storesAndAtomicsMask();
+	auto mask = activeLaneMask() & storesAndAtomicsMask();
 	for(int j = 0; j < SIMD::Width; j++)
 	{
 		If(Extract(mask, j) != 0)
@@ -2620,21 +2615,21 @@
 	return EmitResult::Continue;
 }
 
-SpirvShader::EmitResult SpirvShader::EmitCopyObject(InsnIterator insn, EmitState *state) const
+SpirvShader::EmitResult SpirvShader::EmitState::EmitCopyObject(InsnIterator insn)
 {
-	auto src = Operand(this, state, insn.word(3));
+	auto src = Operand(shader, *this, insn.word(3));
 	if(src.isPointer())
 	{
-		state->createPointer(insn.resultId(), src.Pointer());
+		createPointer(insn.resultId(), src.Pointer());
 	}
 	else if(src.isSampledImage())
 	{
-		state->createSampledImage(insn.resultId(), src.SampledImage());
+		createSampledImage(insn.resultId(), src.SampledImage());
 	}
 	else
 	{
-		auto type = getType(insn.resultTypeId());
-		auto &dst = state->createIntermediate(insn.resultId(), type.componentCount);
+		auto type = shader.getType(insn.resultTypeId());
+		auto &dst = createIntermediate(insn.resultId(), type.componentCount);
 		for(uint32_t i = 0; i < type.componentCount; i++)
 		{
 			dst.move(i, src.Int(i));
@@ -2643,30 +2638,30 @@
 	return EmitResult::Continue;
 }
 
-SpirvShader::EmitResult SpirvShader::EmitArrayLength(InsnIterator insn, EmitState *state) const
+SpirvShader::EmitResult SpirvShader::EmitState::EmitArrayLength(InsnIterator insn)
 {
 	auto structPtrId = Object::ID(insn.word(3));
 	auto arrayFieldIdx = insn.word(4);
 
-	auto &resultType = getType(insn.resultTypeId());
+	auto &resultType = shader.getType(insn.resultTypeId());
 	ASSERT(resultType.componentCount == 1);
 	ASSERT(resultType.definition.opcode() == spv::OpTypeInt);
 
-	auto &structPtrTy = getObjectType(structPtrId);
-	auto &structTy = getType(structPtrTy.element);
+	auto &structPtrTy = shader.getObjectType(structPtrId);
+	auto &structTy = shader.getType(structPtrTy.element);
 	auto arrayId = Type::ID(structTy.definition.word(2 + arrayFieldIdx));
 
-	auto &result = state->createIntermediate(insn.resultId(), 1);
-	auto structBase = GetPointerToData(structPtrId, 0, false, state);
+	auto &result = createIntermediate(insn.resultId(), 1);
+	auto structBase = GetPointerToData(structPtrId, 0, false);
 
 	Decorations structDecorations = {};
-	ApplyDecorationsForIdMember(&structDecorations, structPtrTy.element, arrayFieldIdx);
+	shader.ApplyDecorationsForIdMember(&structDecorations, structPtrTy.element, arrayFieldIdx);
 	ASSERT(structDecorations.HasOffset);
 
 	auto arrayBase = structBase + structDecorations.Offset;
 	auto arraySizeInBytes = SIMD::Int(arrayBase.limit()) - arrayBase.offsets();
 
-	Decorations arrayDecorations = GetDecorationsForId(arrayId);
+	Decorations arrayDecorations = shader.GetDecorationsForId(arrayId);
 	ASSERT(arrayDecorations.HasArrayStride);
 	auto arrayLength = arraySizeInBytes / SIMD::Int(arrayDecorations.ArrayStride);
 
@@ -2675,13 +2670,13 @@
 	return EmitResult::Continue;
 }
 
-SpirvShader::EmitResult SpirvShader::EmitExtendedInstruction(InsnIterator insn, EmitState *state) const
+SpirvShader::EmitResult SpirvShader::EmitState::EmitExtendedInstruction(InsnIterator insn)
 {
-	auto ext = getExtension(insn.word(3));
+	auto ext = shader.getExtension(insn.word(3));
 	switch(ext.name)
 	{
 	case Extension::GLSLstd450:
-		return EmitExtGLSLstd450(insn, state);
+		return EmitExtGLSLstd450(insn);
 	case Extension::NonSemanticInfo:
 		// An extended set name which is prefixed with "NonSemantic." is
 		// guaranteed to contain only non-semantic instructions and all
@@ -2705,26 +2700,22 @@
 {
 	for(auto insn : *this)
 	{
-		switch(insn.opcode())
+		if(insn.opcode() == spv::OpVariable)
 		{
-		case spv::OpVariable:
+			auto &object = getObject(insn.resultId());
+			auto &objectTy = getType(object);
+
+			if(object.kind == Object::Kind::InterfaceVariable && objectTy.storageClass == spv::StorageClassOutput)
 			{
-				auto &object = getObject(insn.resultId());
-				auto &objectTy = getType(object);
-				if(object.kind == Object::Kind::InterfaceVariable && objectTy.storageClass == spv::StorageClassOutput)
-				{
-					auto &dst = routine->getVariable(insn.resultId());
-					int offset = 0;
-					VisitInterface(insn.resultId(),
-					               [&](const Decorations &d, AttribType type) {
-						               auto scalarSlot = d.Location << 2 | d.Component;
-						               routine->outputs[scalarSlot] = dst[offset++];
-					               });
-				}
+				auto &dst = routine->getVariable(insn.resultId());
+				int offset = 0;
+
+				VisitInterface(insn.resultId(),
+				               [&](const Decorations &d, AttribType type) {
+					               auto scalarSlot = d.Location << 2 | d.Component;
+					               routine->outputs[scalarSlot] = dst[offset++];
+				               });
 			}
-			break;
-		default:
-			break;
 		}
 	}
 }
@@ -2763,25 +2754,22 @@
 	}
 }
 
-SpirvShader::Operand::Operand(const SpirvShader *shader, const EmitState *state, SpirvShader::Object::ID objectId)
-    : Operand(state, shader->getObject(objectId))
+SpirvShader::Operand::Operand(const SpirvShader &shader, const EmitState &state, SpirvShader::Object::ID objectId)
+    : Operand(state, shader.getObject(objectId))
 {}
 
-SpirvShader::Operand::Operand(const EmitState *state, const Object &object)
+SpirvShader::Operand::Operand(const EmitState &state, const Object &object)
     : constant(object.kind == SpirvShader::Object::Kind::Constant ? object.constantValue.data() : nullptr)
-    , intermediate(object.kind == SpirvShader::Object::Kind::Intermediate ? &state->getIntermediate(object.id()) : nullptr)
-    , pointer(object.kind == SpirvShader::Object::Kind::Pointer ? &state->getPointer(object.id()) : nullptr)
-    , sampledImage(object.kind == SpirvShader::Object::Kind::SampledImage ? &state->getSampledImage(object.id()) : nullptr)
+    , intermediate(object.kind == SpirvShader::Object::Kind::Intermediate ? &state.getIntermediate(object.id()) : nullptr)
+    , pointer(object.kind == SpirvShader::Object::Kind::Pointer ? &state.getPointer(object.id()) : nullptr)
+    , sampledImage(object.kind == SpirvShader::Object::Kind::SampledImage ? &state.getSampledImage(object.id()) : nullptr)
     , componentCount(intermediate ? intermediate->componentCount : object.constantValue.size())
 {
 	ASSERT(intermediate || constant || pointer || sampledImage);
 }
 
 SpirvShader::Operand::Operand(const Intermediate &value)
-    : constant(nullptr)
-    , intermediate(&value)
-    , pointer(nullptr)
-    , sampledImage(nullptr)
+    : intermediate(&value)
     , componentCount(value.componentCount)
 {
 }
diff --git a/src/Pipeline/SpirvShader.hpp b/src/Pipeline/SpirvShader.hpp
index f4b7d62..51b9fe9 100644
--- a/src/Pipeline/SpirvShader.hpp
+++ b/src/Pipeline/SpirvShader.hpp
@@ -615,7 +615,7 @@
 
 	struct ImageInstruction : public ImageInstructionSignature
 	{
-		ImageInstruction(InsnIterator insn, const SpirvShader &spirv, EmitState *state);
+		ImageInstruction(InsnIterator insn, const SpirvShader &spirv, const EmitState &state);
 
 		const uint32_t position;
 
@@ -1063,148 +1063,6 @@
 	void ProcessInterfaceVariable(Object &object);
 
 public:
-	// EmitState holds control-flow state for the emit() pass.
-	class EmitState
-	{
-	public:
-		EmitState(SpirvRoutine *routine,
-		          Function::ID function,
-		          RValue<SIMD::Int> activeLaneMask,
-		          RValue<SIMD::Int> storesAndAtomicsMask,
-		          const vk::DescriptorSet::Bindings &descriptorSets,
-		          unsigned int multiSampleCount)
-		    : routine(routine)
-		    , function(function)
-		    , activeLaneMaskValue(activeLaneMask.value())
-		    , storesAndAtomicsMaskValue(storesAndAtomicsMask.value())
-		    , descriptorSets(descriptorSets)
-		    , multiSampleCount(multiSampleCount)
-		{
-		}
-
-		// Returns the mask describing the active lanes as updated by dynamic
-		// control flow. Active lanes include helper invocations, used for
-		// calculating fragment derivitives, which must not perform memory
-		// stores or atomic writes.
-		//
-		// Use activeStoresAndAtomicsMask() to consider both control flow and
-		// lanes which are permitted to perform memory stores and atomic
-		// operations
-		RValue<SIMD::Int> activeLaneMask() const
-		{
-			ASSERT(activeLaneMaskValue != nullptr);
-			return RValue<SIMD::Int>(activeLaneMaskValue);
-		}
-
-		// Returns the immutable lane mask that describes which lanes are
-		// permitted to perform memory stores and atomic operations.
-		// Note that unlike activeStoresAndAtomicsMask() this mask *does not*
-		// consider lanes that have been made inactive due to control flow.
-		RValue<SIMD::Int> storesAndAtomicsMask() const
-		{
-			ASSERT(storesAndAtomicsMaskValue != nullptr);
-			return RValue<SIMD::Int>(storesAndAtomicsMaskValue);
-		}
-
-		// Returns a lane mask that describes which lanes are permitted to
-		// perform memory stores and atomic operations, considering lanes that
-		// may have been made inactive due to control flow.
-		RValue<SIMD::Int> activeStoresAndAtomicsMask() const
-		{
-			return activeLaneMask() & storesAndAtomicsMask();
-		}
-
-		// Add a new active lane mask edge from the current block to out.
-		// The edge mask value will be (mask AND activeLaneMaskValue).
-		// If multiple active lane masks are added for the same edge, then
-		// they will be ORed together.
-		void addOutputActiveLaneMaskEdge(Block::ID out, RValue<SIMD::Int> mask);
-
-		// Add a new active lane mask for the edge from -> to.
-		// If multiple active lane masks are added for the same edge, then
-		// they will be ORed together.
-		void addActiveLaneMaskEdge(Block::ID from, Block::ID to, RValue<SIMD::Int> mask);
-
-		SpirvRoutine *routine = nullptr;                 // The current routine being built.
-		Function::ID function;                           // The current function being built.
-		Block::ID block;                                 // The current block being built.
-		rr::Value *activeLaneMaskValue = nullptr;        // The current active lane mask.
-		rr::Value *storesAndAtomicsMaskValue = nullptr;  // The current atomics mask.
-		Block::Set visited;                              // Blocks already built.
-		std::unordered_map<Block::Edge, RValue<SIMD::Int>, Block::Edge::Hash> edgeActiveLaneMasks;
-		std::deque<Block::ID> *pending;
-
-		const vk::DescriptorSet::Bindings &descriptorSets;
-
-		unsigned int getMultiSampleCount() const { return multiSampleCount; }
-
-		Intermediate &createIntermediate(Object::ID id, uint32_t componentCount)
-		{
-			auto it = intermediates.emplace(std::piecewise_construct,
-			                                std::forward_as_tuple(id),
-			                                std::forward_as_tuple(componentCount));
-			ASSERT_MSG(it.second, "Intermediate %d created twice", id.value());
-			return it.first->second;
-		}
-
-		const Intermediate &getIntermediate(Object::ID id) const
-		{
-			auto it = intermediates.find(id);
-			ASSERT_MSG(it != intermediates.end(), "Unknown intermediate %d", id.value());
-			return it->second;
-		}
-
-		void createPointer(Object::ID id, SIMD::Pointer ptr)
-		{
-			bool added = pointers.emplace(id, ptr).second;
-			ASSERT_MSG(added, "Pointer %d created twice", id.value());
-		}
-
-		const SIMD::Pointer &getPointer(Object::ID id) const
-		{
-			auto it = pointers.find(id);
-			ASSERT_MSG(it != pointers.end(), "Unknown pointer %d", id.value());
-			return it->second;
-		}
-
-		void createSampledImage(Object::ID id, SampledImagePointer ptr)
-		{
-			bool added = sampledImages.emplace(id, ptr).second;
-			ASSERT_MSG(added, "Sampled image %d created twice", id.value());
-		}
-
-		const SampledImagePointer &getSampledImage(Object::ID id) const
-		{
-			auto it = sampledImages.find(id);
-			ASSERT_MSG(it != sampledImages.end(), "Unknown sampled image %d", id.value());
-			return it->second;
-		}
-
-		bool isSampledImage(Object::ID id) const
-		{
-			return sampledImages.find(id) != sampledImages.end();
-		}
-
-		const SIMD::Pointer &getImage(Object::ID id) const
-		{
-			return isSampledImage(id) ? getSampledImage(id) : getPointer(id);
-		}
-
-	private:
-		std::unordered_map<Object::ID, Intermediate> intermediates;
-		std::unordered_map<Object::ID, SIMD::Pointer> pointers;
-		std::unordered_map<Object::ID, SampledImagePointer> sampledImages;
-
-		const unsigned int multiSampleCount;
-	};
-
-	// EmitResult is an enumerator of result values from the Emit functions.
-	enum class EmitResult
-	{
-		Continue,    // No termination instructions.
-		Terminator,  // Reached a termination instruction.
-	};
-
 	// Generic wrapper over either per-lane intermediate value, or a constant.
 	// Constants are transparently widened to per-lane values in operator[].
 	// This is appropriate in most cases -- if we're not going to do something
@@ -1212,7 +1070,7 @@
 	class Operand
 	{
 	public:
-		Operand(const SpirvShader *shader, const EmitState *state, SpirvShader::Object::ID objectId);
+		Operand(const SpirvShader &shader, const EmitState &state, SpirvShader::Object::ID objectId);
 		Operand(const Intermediate &value);
 
 		RValue<SIMD::Float> Float(uint32_t i) const
@@ -1276,12 +1134,12 @@
 		RR_PRINT_ONLY(friend struct rr::PrintValue::Ty<Operand>;)
 
 		// Delegate constructor
-		Operand(const EmitState *state, const Object &object);
+		Operand(const EmitState &state, const Object &object);
 
-		const uint32_t *constant;
-		const Intermediate *intermediate;
-		const SIMD::Pointer *pointer;
-		const SampledImagePointer *sampledImage;
+		const uint32_t *constant = nullptr;
+		const Intermediate *intermediate = nullptr;
+		const SIMD::Pointer *pointer = nullptr;
+		const SampledImagePointer *sampledImage = nullptr;
 
 	public:
 		const uint32_t componentCount;
@@ -1289,6 +1147,306 @@
 
 	RR_PRINT_ONLY(friend struct rr::PrintValue::Ty<Operand>;)
 
+	// EmitResult is an enumerator of result values from the Emit functions.
+	enum class EmitResult
+	{
+		Continue,    // No termination instructions.
+		Terminator,  // Reached a termination instruction.
+	};
+
+	// EmitState holds control-flow state for the emit() pass.
+	class EmitState
+	{
+	public:
+		EmitState(const SpirvShader &shader,
+		          SpirvRoutine *routine,
+		          Function::ID function,
+		          RValue<SIMD::Int> activeLaneMask,
+		          RValue<SIMD::Int> storesAndAtomicsMask,
+		          const vk::DescriptorSet::Bindings &descriptorSets,
+		          unsigned int multiSampleCount)
+		    : shader(shader)
+		    , routine(routine)
+		    , function(function)
+		    , activeLaneMaskValue(activeLaneMask.value())
+		    , storesAndAtomicsMaskValue(storesAndAtomicsMask.value())
+		    , descriptorSets(descriptorSets)
+		    , multiSampleCount(multiSampleCount)
+		{
+		}
+
+		// Returns the mask describing the active lanes as updated by dynamic
+		// control flow. Active lanes include helper invocations, used for
+		// calculating fragment derivitives, which must not perform memory
+		// stores or atomic writes.
+		//
+		// Use activeStoresAndAtomicsMask() to consider both control flow and
+		// lanes which are permitted to perform memory stores and atomic
+		// operations
+		RValue<SIMD::Int> activeLaneMask() const
+		{
+			ASSERT(activeLaneMaskValue != nullptr);
+			return RValue<SIMD::Int>(activeLaneMaskValue);
+		}
+
+		// Returns the immutable lane mask that describes which lanes are
+		// permitted to perform memory stores and atomic operations.
+		// Note that unlike activeStoresAndAtomicsMask() this mask *does not*
+		// consider lanes that have been made inactive due to control flow.
+		RValue<SIMD::Int> storesAndAtomicsMask() const
+		{
+			ASSERT(storesAndAtomicsMaskValue != nullptr);
+			return RValue<SIMD::Int>(storesAndAtomicsMaskValue);
+		}
+
+		// Returns a lane mask that describes which lanes are permitted to
+		// perform memory stores and atomic operations, considering lanes that
+		// may have been made inactive due to control flow.
+		RValue<SIMD::Int> activeStoresAndAtomicsMask() const
+		{
+			return activeLaneMask() & storesAndAtomicsMask();
+		}
+
+		// Add a new active lane mask edge from the current block to out.
+		// The edge mask value will be (mask AND activeLaneMaskValue).
+		// If multiple active lane masks are added for the same edge, then
+		// they will be ORed together.
+		void addOutputActiveLaneMaskEdge(Block::ID out, RValue<SIMD::Int> mask);
+
+		// Add a new active lane mask for the edge from -> to.
+		// If multiple active lane masks are added for the same edge, then
+		// they will be ORed together.
+		void addActiveLaneMaskEdge(Block::ID from, Block::ID to, RValue<SIMD::Int> mask);
+
+		unsigned int getMultiSampleCount() const { return multiSampleCount; }
+
+		Intermediate &createIntermediate(Object::ID id, uint32_t componentCount)
+		{
+			auto it = intermediates.emplace(std::piecewise_construct,
+			                                std::forward_as_tuple(id),
+			                                std::forward_as_tuple(componentCount));
+			ASSERT_MSG(it.second, "Intermediate %d created twice", id.value());
+			return it.first->second;
+		}
+
+		const Intermediate &getIntermediate(Object::ID id) const
+		{
+			auto it = intermediates.find(id);
+			ASSERT_MSG(it != intermediates.end(), "Unknown intermediate %d", id.value());
+			return it->second;
+		}
+
+		void createPointer(Object::ID id, SIMD::Pointer ptr)
+		{
+			bool added = pointers.emplace(id, ptr).second;
+			ASSERT_MSG(added, "Pointer %d created twice", id.value());
+		}
+
+		const SIMD::Pointer &getPointer(Object::ID id) const
+		{
+			auto it = pointers.find(id);
+			ASSERT_MSG(it != pointers.end(), "Unknown pointer %d", id.value());
+			return it->second;
+		}
+
+		void createSampledImage(Object::ID id, SampledImagePointer ptr)
+		{
+			bool added = sampledImages.emplace(id, ptr).second;
+			ASSERT_MSG(added, "Sampled image %d created twice", id.value());
+		}
+
+		const SampledImagePointer &getSampledImage(Object::ID id) const
+		{
+			auto it = sampledImages.find(id);
+			ASSERT_MSG(it != sampledImages.end(), "Unknown sampled image %d", id.value());
+			return it->second;
+		}
+
+		bool isSampledImage(Object::ID id) const
+		{
+			return sampledImages.find(id) != sampledImages.end();
+		}
+
+		const SIMD::Pointer &getImage(Object::ID id) const
+		{
+			return isSampledImage(id) ? getSampledImage(id) : getPointer(id);
+		}
+
+		EmitResult EmitVariable(InsnIterator insn);
+		EmitResult EmitLoad(InsnIterator insn);
+		EmitResult EmitStore(InsnIterator insn);
+		EmitResult EmitAccessChain(InsnIterator insn);
+		EmitResult EmitCompositeConstruct(InsnIterator insn);
+		EmitResult EmitCompositeInsert(InsnIterator insn);
+		EmitResult EmitCompositeExtract(InsnIterator insn);
+		EmitResult EmitVectorShuffle(InsnIterator insn);
+		EmitResult EmitVectorTimesScalar(InsnIterator insn);
+		EmitResult EmitMatrixTimesVector(InsnIterator insn);
+		EmitResult EmitVectorTimesMatrix(InsnIterator insn);
+		EmitResult EmitMatrixTimesMatrix(InsnIterator insn);
+		EmitResult EmitOuterProduct(InsnIterator insn);
+		EmitResult EmitTranspose(InsnIterator insn);
+		EmitResult EmitVectorExtractDynamic(InsnIterator insn);
+		EmitResult EmitVectorInsertDynamic(InsnIterator insn);
+		EmitResult EmitUnaryOp(InsnIterator insn);
+		EmitResult EmitBinaryOp(InsnIterator insn);
+		EmitResult EmitDot(InsnIterator insn);
+		EmitResult EmitSelect(InsnIterator insn);
+		EmitResult EmitExtendedInstruction(InsnIterator insn);
+		EmitResult EmitExtGLSLstd450(InsnIterator insn);
+		EmitResult EmitAny(InsnIterator insn);
+		EmitResult EmitAll(InsnIterator insn);
+		EmitResult EmitBranch(InsnIterator insn);
+		EmitResult EmitBranchConditional(InsnIterator insn);
+		EmitResult EmitSwitch(InsnIterator insn);
+		EmitResult EmitUnreachable(InsnIterator insn);
+		EmitResult EmitReturn(InsnIterator insn);
+		EmitResult EmitTerminateInvocation(InsnIterator insn);
+		EmitResult EmitDemoteToHelperInvocation(InsnIterator insn);
+		EmitResult EmitIsHelperInvocation(InsnIterator insn);
+		EmitResult EmitFunctionCall(InsnIterator insn);
+		EmitResult EmitPhi(InsnIterator insn);
+		EmitResult EmitImageSample(const ImageInstruction &instruction);
+		EmitResult EmitImageQuerySizeLod(InsnIterator insn);
+		EmitResult EmitImageQuerySize(InsnIterator insn);
+		EmitResult EmitImageQueryLevels(InsnIterator insn);
+		EmitResult EmitImageQuerySamples(InsnIterator insn);
+		EmitResult EmitImageRead(const ImageInstruction &instruction);
+		EmitResult EmitImageWrite(const ImageInstruction &instruction) const;
+		EmitResult EmitImageTexelPointer(const ImageInstruction &instruction);
+		EmitResult EmitAtomicOp(InsnIterator insn);
+		EmitResult EmitAtomicCompareExchange(InsnIterator insn);
+		EmitResult EmitSampledImage(InsnIterator insn);
+		EmitResult EmitImage(InsnIterator insn);
+		EmitResult EmitCopyObject(InsnIterator insn);
+		EmitResult EmitCopyMemory(InsnIterator insn);
+		EmitResult EmitControlBarrier(InsnIterator insn) const;
+		EmitResult EmitMemoryBarrier(InsnIterator insn);
+		EmitResult EmitGroupNonUniform(InsnIterator insn);
+		EmitResult EmitArrayLength(InsnIterator insn);
+		EmitResult EmitBitcastPointer(Object::ID resultID, Operand &src);
+
+		enum InterpolationType
+		{
+			Centroid,
+			AtSample,
+			AtOffset,
+		};
+		SIMD::Float EmitInterpolate(const SIMD::Pointer &ptr, int32_t location, Object::ID paramId,
+		                            uint32_t component, InterpolationType type) const;
+
+		SIMD::Pointer WalkExplicitLayoutAccessChain(Object::ID id, Object::ID elementId, const Span &indexIds, bool nonUniform) const;
+		SIMD::Pointer WalkAccessChain(Object::ID id, Object::ID elementId, const Span &indexIds, bool nonUniform) const;
+
+		// Returns a SIMD::Pointer to the underlying data for the given pointer
+		// object.
+		// Handles objects of the following kinds:
+		//  - DescriptorSet
+		//  - Pointer
+		//  - InterfaceVariable
+		// Calling GetPointerToData with objects of any other kind will assert.
+		SIMD::Pointer GetPointerToData(Object::ID id, SIMD::Int arrayIndex, bool nonUniform) const;
+		void OffsetToElement(SIMD::Pointer &ptr, Object::ID elementId, int32_t arrayStride) const;
+
+		/* image istructions */
+
+		// Emits code to sample an image, regardless of whether any SIMD lanes are active.
+		void EmitImageSampleUnconditional(Array<SIMD::Float> &out, const ImageInstruction &instruction) const;
+
+		Pointer<Byte> getSamplerDescriptor(Pointer<Byte> imageDescriptor, const ImageInstruction &instruction) const;
+		Pointer<Byte> getSamplerDescriptor(Pointer<Byte> imageDescriptor, const ImageInstruction &instruction, int laneIdx) const;
+		Pointer<Byte> lookupSamplerFunction(Pointer<Byte> imageDescriptor, Pointer<Byte> samplerDescriptor, const ImageInstruction &instruction) const;
+		void callSamplerFunction(Pointer<Byte> samplerFunction, Array<SIMD::Float> &out, Pointer<Byte> imageDescriptor, const ImageInstruction &instruction) const;
+
+		void GetImageDimensions(const Type &resultTy, Object::ID imageId, Object::ID lodId, Intermediate &dst) const;
+		struct TexelAddressData
+		{
+			bool isArrayed;
+			spv::Dim dim;
+			int dims, texelSize;
+			SIMD::Int u, v, w, ptrOffset;
+		};
+		static TexelAddressData setupTexelAddressData(SIMD::Int rowPitch, SIMD::Int slicePitch, SIMD::Int samplePitch, ImageInstructionSignature instruction, SIMD::Int coordinate[], SIMD::Int sample, vk::Format imageFormat, const SpirvRoutine *routine);
+		static SIMD::Pointer GetNonUniformTexelAddress(ImageInstructionSignature instruction, SIMD::Pointer descriptor, SIMD::Int coordinate[], SIMD::Int sample, vk::Format imageFormat, OutOfBoundsBehavior outOfBoundsBehavior, SIMD::Int activeLaneMask, const SpirvRoutine *routine);
+		static SIMD::Pointer GetTexelAddress(ImageInstructionSignature instruction, Pointer<Byte> descriptor, SIMD::Int coordinate[], SIMD::Int sample, vk::Format imageFormat, OutOfBoundsBehavior outOfBoundsBehavior, const SpirvRoutine *routine);
+		static void WriteImage(ImageInstructionSignature instruction, Pointer<Byte> descriptor, const Pointer<SIMD::Int> &coord, const Pointer<SIMD::Int> &texelAndMask, vk::Format imageFormat);
+
+		/* control flow */
+
+		// Lookup the active lane mask for the edge from -> to.
+		// If from is unreachable, then a mask of all zeros is returned.
+		// Asserts if from is reachable and the edge does not exist.
+		RValue<SIMD::Int> GetActiveLaneMaskEdge(Block::ID from, Block::ID to) const;
+
+		// Updates the current active lane mask.
+		void SetActiveLaneMask(RValue<SIMD::Int> mask);
+		void SetStoresAndAtomicsMask(RValue<SIMD::Int> mask);
+
+		// Emit all the unvisited blocks (except for ignore) in DFS order,
+		// starting with id.
+		void EmitBlocks(Block::ID id, Block::ID ignore = 0);
+		void EmitNonLoop();
+		void EmitLoop();
+
+		void EmitInstructions(InsnIterator begin, InsnIterator end);
+		EmitResult EmitInstruction(InsnIterator insn);
+
+		// Helper for implementing OpStore, which doesn't take an InsnIterator so it
+		// can also store independent operands.
+		void Store(Object::ID pointerId, const Operand &value, bool atomic, std::memory_order memoryOrder) const;
+
+		// LoadPhi loads the phi values from the alloca storage and places the
+		// load values into the intermediate with the phi's result id.
+		void LoadPhi(InsnIterator insn);
+
+		// StorePhi updates the phi's alloca storage value using the incoming
+		// values from blocks that are both in the OpPhi instruction and in
+		// filter.
+		void StorePhi(Block::ID blockID, InsnIterator insn, const std::unordered_set<SpirvShader::Block::ID> &filter) const;
+
+		// Emits a rr::Fence for the given MemorySemanticsMask.
+		void Fence(spv::MemorySemanticsMask semantics) const;
+
+		// Helper for calling rr::Yield with res cast to an rr::Int.
+		void Yield(YieldResult res) const;
+
+		// Helper as we often need to take dot products as part of doing other things.
+		static SIMD::Float FDot(unsigned numComponents, const Operand &x, const Operand &y);
+		static SIMD::Int SDot(unsigned numComponents, const Operand &x, const Operand &y, const Operand *accum);
+		static SIMD::UInt UDot(unsigned numComponents, const Operand &x, const Operand &y, const Operand *accum);
+		static SIMD::Int SUDot(unsigned numComponents, const Operand &x, const Operand &y, const Operand *accum);
+		static SIMD::Int AddSat(RValue<SIMD::Int> a, RValue<SIMD::Int> b);
+		static SIMD::UInt AddSat(RValue<SIMD::UInt> a, RValue<SIMD::UInt> b);
+
+		static ImageSampler *getImageSampler(const vk::Device *device, uint32_t signature, uint32_t samplerId, uint32_t imageViewId);
+		static std::shared_ptr<rr::Routine> emitSamplerRoutine(ImageInstructionSignature instruction, const Sampler &samplerState);
+		static std::shared_ptr<rr::Routine> emitWriteRoutine(ImageInstructionSignature instruction, const Sampler &samplerState);
+
+		// TODO(b/129523279): Eliminate conversion and use vk::Sampler members directly.
+		static sw::FilterType convertFilterMode(const vk::SamplerState *samplerState, VkImageViewType imageViewType, SamplerMethod samplerMethod);
+		static sw::MipmapType convertMipmapMode(const vk::SamplerState *samplerState);
+		static sw::AddressingMode convertAddressingMode(int coordinateIndex, const vk::SamplerState *samplerState, VkImageViewType imageViewType);
+
+	private:
+		const SpirvShader &shader;
+		SpirvRoutine *const routine;                     // The current routine being built.
+		Function::ID function;                           // The current function being built.
+		Block::ID block;                                 // The current block being built.
+		rr::Value *activeLaneMaskValue = nullptr;        // The current active lane mask.
+		rr::Value *storesAndAtomicsMaskValue = nullptr;  // The current atomics mask.
+		Block::Set visited;                              // Blocks already built.
+		std::unordered_map<Block::Edge, RValue<SIMD::Int>, Block::Edge::Hash> edgeActiveLaneMasks;
+		std::deque<Block::ID> *pending;
+
+		const vk::DescriptorSet::Bindings &descriptorSets;
+
+		std::unordered_map<Object::ID, Intermediate> intermediates;
+		std::unordered_map<Object::ID, SIMD::Pointer> pointers;
+		std::unordered_map<Object::ID, SampledImagePointer> sampledImages;
+
+		const unsigned int multiSampleCount;
+	};
+
 	const Type &getType(Type::ID id) const
 	{
 		auto it = types.find(id);
@@ -1335,118 +1493,11 @@
 		return it->second;
 	}
 
-	// Returns a SIMD::Pointer to the underlying data for the given pointer
-	// object.
-	// Handles objects of the following kinds:
-	//  - DescriptorSet
-	//  - Pointer
-	//  - InterfaceVariable
-	// Calling GetPointerToData with objects of any other kind will assert.
-	SIMD::Pointer GetPointerToData(Object::ID id, SIMD::Int arrayIndex, bool nonUniform, const EmitState *state) const;
-	void OffsetToElement(SIMD::Pointer &ptr, Object::ID elementId, int32_t arrayStride, const EmitState *state) const;
-
-	OutOfBoundsBehavior getOutOfBoundsBehavior(Object::ID pointerId, const EmitState *state) const;
-
-	SIMD::Pointer WalkExplicitLayoutAccessChain(Object::ID id, Object::ID elementId, const Span &indexIds, bool nonUniform, const EmitState *state) const;
-	SIMD::Pointer WalkAccessChain(Object::ID id, Object::ID elementId, const Span &indexIds, bool nonUniform, const EmitState *state) const;
+	OutOfBoundsBehavior getOutOfBoundsBehavior(Object::ID pointerId, const vk::PipelineLayout *pipelineLayout) const;
 
 	// Returns the *component* offset in the literal for the given access chain.
 	uint32_t WalkLiteralAccessChain(Type::ID id, const Span &indexes) const;
 
-	// Lookup the active lane mask for the edge from -> to.
-	// If from is unreachable, then a mask of all zeros is returned.
-	// Asserts if from is reachable and the edge does not exist.
-	RValue<SIMD::Int> GetActiveLaneMaskEdge(EmitState *state, Block::ID from, Block::ID to) const;
-
-	// Updates the current active lane mask.
-	void SetActiveLaneMask(RValue<SIMD::Int> mask, EmitState *state) const;
-	void SetStoresAndAtomicsMask(RValue<SIMD::Int> mask, EmitState *state) const;
-
-	// Emit all the unvisited blocks (except for ignore) in DFS order,
-	// starting with id.
-	void EmitBlocks(Block::ID id, EmitState *state, Block::ID ignore = 0) const;
-	void EmitNonLoop(EmitState *state) const;
-	void EmitLoop(EmitState *state) const;
-
-	void EmitInstructions(InsnIterator begin, InsnIterator end, EmitState *state) const;
-	EmitResult EmitInstruction(InsnIterator insn, EmitState *state) const;
-
-	// Emit pass instructions:
-	EmitResult EmitVariable(InsnIterator insn, EmitState *state) const;
-	EmitResult EmitLoad(InsnIterator insn, EmitState *state) const;
-	EmitResult EmitStore(InsnIterator insn, EmitState *state) const;
-	EmitResult EmitAccessChain(InsnIterator insn, EmitState *state) const;
-	EmitResult EmitCompositeConstruct(InsnIterator insn, EmitState *state) const;
-	EmitResult EmitCompositeInsert(InsnIterator insn, EmitState *state) const;
-	EmitResult EmitCompositeExtract(InsnIterator insn, EmitState *state) const;
-	EmitResult EmitVectorShuffle(InsnIterator insn, EmitState *state) const;
-	EmitResult EmitVectorTimesScalar(InsnIterator insn, EmitState *state) const;
-	EmitResult EmitMatrixTimesVector(InsnIterator insn, EmitState *state) const;
-	EmitResult EmitVectorTimesMatrix(InsnIterator insn, EmitState *state) const;
-	EmitResult EmitMatrixTimesMatrix(InsnIterator insn, EmitState *state) const;
-	EmitResult EmitOuterProduct(InsnIterator insn, EmitState *state) const;
-	EmitResult EmitTranspose(InsnIterator insn, EmitState *state) const;
-	EmitResult EmitVectorExtractDynamic(InsnIterator insn, EmitState *state) const;
-	EmitResult EmitVectorInsertDynamic(InsnIterator insn, EmitState *state) const;
-	EmitResult EmitUnaryOp(InsnIterator insn, EmitState *state) const;
-	EmitResult EmitBinaryOp(InsnIterator insn, EmitState *state) const;
-	EmitResult EmitDot(InsnIterator insn, EmitState *state) const;
-	EmitResult EmitSelect(InsnIterator insn, EmitState *state) const;
-	EmitResult EmitExtendedInstruction(InsnIterator insn, EmitState *state) const;
-	EmitResult EmitExtGLSLstd450(InsnIterator insn, EmitState *state) const;
-	EmitResult EmitLine(InsnIterator insn, EmitState *state) const;
-	EmitResult EmitAny(InsnIterator insn, EmitState *state) const;
-	EmitResult EmitAll(InsnIterator insn, EmitState *state) const;
-	EmitResult EmitBranch(InsnIterator insn, EmitState *state) const;
-	EmitResult EmitBranchConditional(InsnIterator insn, EmitState *state) const;
-	EmitResult EmitSwitch(InsnIterator insn, EmitState *state) const;
-	EmitResult EmitUnreachable(InsnIterator insn, EmitState *state) const;
-	EmitResult EmitReturn(InsnIterator insn, EmitState *state) const;
-	EmitResult EmitTerminateInvocation(InsnIterator insn, EmitState *state) const;
-	EmitResult EmitDemoteToHelperInvocation(InsnIterator insn, EmitState *state) const;
-	EmitResult EmitIsHelperInvocation(InsnIterator insn, EmitState *state) const;
-	EmitResult EmitFunctionCall(InsnIterator insn, EmitState *state) const;
-	EmitResult EmitPhi(InsnIterator insn, EmitState *state) const;
-	EmitResult EmitImageSample(const ImageInstruction &instruction, EmitState *state) const;
-	EmitResult EmitImageQuerySizeLod(InsnIterator insn, EmitState *state) const;
-	EmitResult EmitImageQuerySize(InsnIterator insn, EmitState *state) const;
-	EmitResult EmitImageQueryLevels(InsnIterator insn, EmitState *state) const;
-	EmitResult EmitImageQuerySamples(InsnIterator insn, EmitState *state) const;
-	EmitResult EmitImageRead(const ImageInstruction &instruction, EmitState *state) const;
-	EmitResult EmitImageWrite(const ImageInstruction &instruction, EmitState *state) const;
-	EmitResult EmitImageTexelPointer(const ImageInstruction &instruction, EmitState *state) const;
-	EmitResult EmitAtomicOp(InsnIterator insn, EmitState *state) const;
-	EmitResult EmitAtomicCompareExchange(InsnIterator insn, EmitState *state) const;
-	EmitResult EmitSampledImage(InsnIterator insn, EmitState *state) const;
-	EmitResult EmitImage(InsnIterator insn, EmitState *state) const;
-	EmitResult EmitCopyObject(InsnIterator insn, EmitState *state) const;
-	EmitResult EmitCopyMemory(InsnIterator insn, EmitState *state) const;
-	EmitResult EmitControlBarrier(InsnIterator insn, EmitState *state) const;
-	EmitResult EmitMemoryBarrier(InsnIterator insn, EmitState *state) const;
-	EmitResult EmitGroupNonUniform(InsnIterator insn, EmitState *state) const;
-	EmitResult EmitArrayLength(InsnIterator insn, EmitState *state) const;
-	EmitResult EmitPointerBitCast(Object::ID resultID, Operand &src, EmitState *state) const;
-
-	// Emits code to sample an image, regardless of whether any SIMD lanes are active.
-	void EmitImageSampleUnconditional(Array<SIMD::Float> &out, const ImageInstruction &instruction, EmitState *state) const;
-
-	Pointer<Byte> getSamplerDescriptor(Pointer<Byte> imageDescriptor, const ImageInstruction &instruction, EmitState *state) const;
-	Pointer<Byte> getSamplerDescriptor(Pointer<Byte> imageDescriptor, const ImageInstruction &instruction, int laneIdx, EmitState *state) const;
-	Pointer<Byte> lookupSamplerFunction(Pointer<Byte> imageDescriptor, Pointer<Byte> samplerDescriptor, const ImageInstruction &instruction, EmitState *state) const;
-	void callSamplerFunction(Pointer<Byte> samplerFunction, Array<SIMD::Float> &out, Pointer<Byte> imageDescriptor, const ImageInstruction &instruction, EmitState *state) const;
-
-	void GetImageDimensions(const EmitState *state, const Type &resultTy, Object::ID imageId, Object::ID lodId, Intermediate &dst) const;
-	struct TexelAddressData
-	{
-		bool isArrayed;
-		spv::Dim dim;
-		int dims, texelSize;
-		SIMD::Int u, v, w, ptrOffset;
-	};
-	static TexelAddressData setupTexelAddressData(SIMD::Int rowPitch, SIMD::Int slicePitch, SIMD::Int samplePitch, ImageInstructionSignature instruction, SIMD::Int coordinate[], SIMD::Int sample, vk::Format imageFormat, const EmitState *state);
-	static SIMD::Pointer GetNonUniformTexelAddress(ImageInstructionSignature instruction, SIMD::Pointer descriptor, SIMD::Int coordinate[], SIMD::Int sample, vk::Format imageFormat, OutOfBoundsBehavior outOfBoundsBehavior, const EmitState *state);
-	static SIMD::Pointer GetTexelAddress(ImageInstructionSignature instruction, Pointer<Byte> descriptor, SIMD::Int coordinate[], SIMD::Int sample, vk::Format imageFormat, OutOfBoundsBehavior outOfBoundsBehavior, const EmitState *state);
-	static void WriteImage(ImageInstructionSignature instruction, Pointer<Byte> descriptor, const Pointer<SIMD::Int> &coord, const Pointer<SIMD::Int> &texelAndMask, vk::Format imageFormat);
 	uint32_t GetConstScalarInt(Object::ID id) const;
 	void EvalSpecConstantOp(InsnIterator insn);
 	void EvalSpecConstantUnaryOp(InsnIterator insn);
@@ -1455,33 +1506,6 @@
 	// Fragment input interpolation functions
 	uint32_t GetNumInputComponents(int32_t location) const;
 	uint32_t GetPackedInterpolant(int32_t location) const;
-	enum InterpolationType
-	{
-		Centroid,
-		AtSample,
-		AtOffset,
-	};
-	SIMD::Float EmitInterpolate(const SIMD::Pointer &ptr, int32_t location, Object::ID paramId,
-	                            uint32_t component, EmitState *state, InterpolationType type) const;
-
-	// Helper for implementing OpStore, which doesn't take an InsnIterator so it
-	// can also store independent operands.
-	void Store(Object::ID pointerId, const Operand &value, bool atomic, std::memory_order memoryOrder, EmitState *state) const;
-
-	// LoadPhi loads the phi values from the alloca storage and places the
-	// load values into the intermediate with the phi's result id.
-	void LoadPhi(InsnIterator insn, EmitState *state) const;
-
-	// StorePhi updates the phi's alloca storage value using the incoming
-	// values from blocks that are both in the OpPhi instruction and in
-	// filter.
-	void StorePhi(Block::ID blockID, InsnIterator insn, EmitState *state, const std::unordered_set<SpirvShader::Block::ID> &filter) const;
-
-	// Emits a rr::Fence for the given MemorySemanticsMask.
-	void Fence(spv::MemorySemanticsMask semantics) const;
-
-	// Helper for calling rr::Yield with res cast to an rr::Int.
-	void Yield(YieldResult res) const;
 
 	// WriteCFGGraphVizDotFile() writes a graphviz dot file of the shader's
 	// control flow to the given file path.
@@ -1501,23 +1525,6 @@
 	// has a result type ID and result ID, i.e. defines an Object.
 	static bool HasTypeAndResult(spv::Op op);
 
-	// Helper as we often need to take dot products as part of doing other things.
-	static SIMD::Float FDot(unsigned numComponents, const Operand &x, const Operand &y);
-	static SIMD::Int SDot(unsigned numComponents, const Operand &x, const Operand &y, const Operand *accum);
-	static SIMD::UInt UDot(unsigned numComponents, const Operand &x, const Operand &y, const Operand *accum);
-	static SIMD::Int SUDot(unsigned numComponents, const Operand &x, const Operand &y, const Operand *accum);
-	static SIMD::Int AddSat(RValue<SIMD::Int> a, RValue<SIMD::Int> b);
-	static SIMD::UInt AddSat(RValue<SIMD::UInt> a, RValue<SIMD::UInt> b);
-
-	static ImageSampler *getImageSampler(const vk::Device *device, uint32_t signature, uint32_t samplerId, uint32_t imageViewId);
-	static std::shared_ptr<rr::Routine> emitSamplerRoutine(ImageInstructionSignature instruction, const Sampler &samplerState);
-	static std::shared_ptr<rr::Routine> emitWriteRoutine(ImageInstructionSignature instruction, const Sampler &samplerState);
-
-	// TODO(b/129523279): Eliminate conversion and use vk::Sampler members directly.
-	static sw::FilterType convertFilterMode(const vk::SamplerState *samplerState, VkImageViewType imageViewType, SamplerMethod samplerMethod);
-	static sw::MipmapType convertMipmapMode(const vk::SamplerState *samplerState);
-	static sw::AddressingMode convertAddressingMode(int coordinateIndex, const vk::SamplerState *samplerState, VkImageViewType imageViewType);
-
 	// Returns 0 when invalid.
 	static VkShaderStageFlagBits executionModelToStage(spv::ExecutionModel model);
 };
diff --git a/src/Pipeline/SpirvShaderArithmetic.cpp b/src/Pipeline/SpirvShaderArithmetic.cpp
index e26a955..8eee57b 100644
--- a/src/Pipeline/SpirvShaderArithmetic.cpp
+++ b/src/Pipeline/SpirvShaderArithmetic.cpp
@@ -23,12 +23,12 @@
 
 namespace sw {
 
-SpirvShader::EmitResult SpirvShader::EmitVectorTimesScalar(InsnIterator insn, EmitState *state) const
+SpirvShader::EmitResult SpirvShader::EmitState::EmitVectorTimesScalar(InsnIterator insn)
 {
-	auto &type = getType(insn.resultTypeId());
-	auto &dst = state->createIntermediate(insn.resultId(), type.componentCount);
-	auto lhs = Operand(this, state, insn.word(3));
-	auto rhs = Operand(this, state, insn.word(4));
+	auto &type = shader.getType(insn.resultTypeId());
+	auto &dst = createIntermediate(insn.resultId(), type.componentCount);
+	auto lhs = Operand(shader, *this, insn.word(3));
+	auto rhs = Operand(shader, *this, insn.word(4));
 
 	for(auto i = 0u; i < type.componentCount; i++)
 	{
@@ -38,12 +38,12 @@
 	return EmitResult::Continue;
 }
 
-SpirvShader::EmitResult SpirvShader::EmitMatrixTimesVector(InsnIterator insn, EmitState *state) const
+SpirvShader::EmitResult SpirvShader::EmitState::EmitState::EmitMatrixTimesVector(InsnIterator insn)
 {
-	auto &type = getType(insn.resultTypeId());
-	auto &dst = state->createIntermediate(insn.resultId(), type.componentCount);
-	auto lhs = Operand(this, state, insn.word(3));
-	auto rhs = Operand(this, state, insn.word(4));
+	auto &type = shader.getType(insn.resultTypeId());
+	auto &dst = createIntermediate(insn.resultId(), type.componentCount);
+	auto lhs = Operand(shader, *this, insn.word(3));
+	auto rhs = Operand(shader, *this, insn.word(4));
 
 	for(auto i = 0u; i < type.componentCount; i++)
 	{
@@ -58,12 +58,12 @@
 	return EmitResult::Continue;
 }
 
-SpirvShader::EmitResult SpirvShader::EmitVectorTimesMatrix(InsnIterator insn, EmitState *state) const
+SpirvShader::EmitResult SpirvShader::EmitState::EmitVectorTimesMatrix(InsnIterator insn)
 {
-	auto &type = getType(insn.resultTypeId());
-	auto &dst = state->createIntermediate(insn.resultId(), type.componentCount);
-	auto lhs = Operand(this, state, insn.word(3));
-	auto rhs = Operand(this, state, insn.word(4));
+	auto &type = shader.getType(insn.resultTypeId());
+	auto &dst = createIntermediate(insn.resultId(), type.componentCount);
+	auto lhs = Operand(shader, *this, insn.word(3));
+	auto rhs = Operand(shader, *this, insn.word(4));
 
 	for(auto i = 0u; i < type.componentCount; i++)
 	{
@@ -78,16 +78,16 @@
 	return EmitResult::Continue;
 }
 
-SpirvShader::EmitResult SpirvShader::EmitMatrixTimesMatrix(InsnIterator insn, EmitState *state) const
+SpirvShader::EmitResult SpirvShader::EmitState::EmitMatrixTimesMatrix(InsnIterator insn)
 {
-	auto &type = getType(insn.resultTypeId());
-	auto &dst = state->createIntermediate(insn.resultId(), type.componentCount);
-	auto lhs = Operand(this, state, insn.word(3));
-	auto rhs = Operand(this, state, insn.word(4));
+	auto &type = shader.getType(insn.resultTypeId());
+	auto &dst = createIntermediate(insn.resultId(), type.componentCount);
+	auto lhs = Operand(shader, *this, insn.word(3));
+	auto rhs = Operand(shader, *this, insn.word(4));
 
 	auto numColumns = type.definition.word(3);
-	auto numRows = getType(type.definition.word(2)).definition.word(3);
-	auto numAdds = getObjectType(insn.word(3)).definition.word(3);
+	auto numRows = shader.getType(type.definition.word(2)).definition.word(3);
+	auto numAdds = shader.getObjectType(insn.word(3)).definition.word(3);
 
 	for(auto row = 0u; row < numRows; row++)
 	{
@@ -105,12 +105,12 @@
 	return EmitResult::Continue;
 }
 
-SpirvShader::EmitResult SpirvShader::EmitOuterProduct(InsnIterator insn, EmitState *state) const
+SpirvShader::EmitResult SpirvShader::EmitState::EmitOuterProduct(InsnIterator insn)
 {
-	auto &type = getType(insn.resultTypeId());
-	auto &dst = state->createIntermediate(insn.resultId(), type.componentCount);
-	auto lhs = Operand(this, state, insn.word(3));
-	auto rhs = Operand(this, state, insn.word(4));
+	auto &type = shader.getType(insn.resultTypeId());
+	auto &dst = createIntermediate(insn.resultId(), type.componentCount);
+	auto lhs = Operand(shader, *this, insn.word(3));
+	auto rhs = Operand(shader, *this, insn.word(4));
 
 	auto numRows = lhs.componentCount;
 	auto numCols = rhs.componentCount;
@@ -126,14 +126,14 @@
 	return EmitResult::Continue;
 }
 
-SpirvShader::EmitResult SpirvShader::EmitTranspose(InsnIterator insn, EmitState *state) const
+SpirvShader::EmitResult SpirvShader::EmitState::EmitState::EmitTranspose(InsnIterator insn)
 {
-	auto &type = getType(insn.resultTypeId());
-	auto &dst = state->createIntermediate(insn.resultId(), type.componentCount);
-	auto mat = Operand(this, state, insn.word(3));
+	auto &type = shader.getType(insn.resultTypeId());
+	auto &dst = createIntermediate(insn.resultId(), type.componentCount);
+	auto mat = Operand(shader, *this, insn.word(3));
 
 	auto numCols = type.definition.word(3);
-	auto numRows = getType(type.definition.word(2)).componentCount;
+	auto numRows = shader.getType(type.definition.word(2)).componentCount;
 
 	for(auto col = 0u; col < numCols; col++)
 	{
@@ -146,7 +146,7 @@
 	return EmitResult::Continue;
 }
 
-SpirvShader::EmitResult SpirvShader::EmitPointerBitCast(Object::ID resultID, Operand &src, EmitState *state) const
+SpirvShader::EmitResult SpirvShader::EmitState::EmitBitcastPointer(Object::ID resultID, Operand &src)
 {
 	if(src.isPointer())  // Pointer -> Integer bits
 	{
@@ -155,7 +155,7 @@
 			SIMD::UInt bits;
 			src.Pointer().castTo(bits);
 
-			auto &dst = state->createIntermediate(resultID, 1);
+			auto &dst = createIntermediate(resultID, 1);
 			dst.move(0, bits);
 		}
 		else  // 64-bit pointers
@@ -166,7 +166,7 @@
 			SIMD::UInt lowerBits, upperBits;
 			ptr.castTo(lowerBits, upperBits);
 
-			auto &dst = state->createIntermediate(resultID, 2);
+			auto &dst = createIntermediate(resultID, 2);
 			dst.move(0, lowerBits);
 			dst.move(1, upperBits);
 		}
@@ -175,35 +175,35 @@
 	{
 		if(sizeof(void *) == 4)  // 32-bit pointers
 		{
-			state->createPointer(resultID, SIMD::Pointer(src.UInt(0)));
+			createPointer(resultID, SIMD::Pointer(src.UInt(0)));
 		}
 		else  // 64-bit pointers
 		{
 			ASSERT(sizeof(void *) == 8);
 			// Casting two 32-bit integers into a 64-bit pointer
-			state->createPointer(resultID, SIMD::Pointer(src.UInt(0), src.UInt(1)));
+			createPointer(resultID, SIMD::Pointer(src.UInt(0), src.UInt(1)));
 		}
 	}
 
 	return EmitResult::Continue;
 }
 
-SpirvShader::EmitResult SpirvShader::EmitUnaryOp(InsnIterator insn, EmitState *state) const
+SpirvShader::EmitResult SpirvShader::EmitState::EmitUnaryOp(InsnIterator insn)
 {
-	auto &type = getType(insn.resultTypeId());
-	auto src = Operand(this, state, insn.word(3));
+	auto &type = shader.getType(insn.resultTypeId());
+	auto src = Operand(shader, *this, insn.word(3));
 
-	bool dstIsPointer = getObject(insn.resultId()).kind == Object::Kind::Pointer;
+	bool dstIsPointer = shader.getObject(insn.resultId()).kind == Object::Kind::Pointer;
 	bool srcIsPointer = src.isPointer();
 	if(srcIsPointer || dstIsPointer)
 	{
 		ASSERT(insn.opcode() == spv::OpBitcast);
-		ASSERT((srcIsPointer || (type.componentCount == 1)));  // When the ouput is a pointer, it's a single pointer
+		ASSERT(srcIsPointer || (type.componentCount == 1));  // When the ouput is a pointer, it's a single pointer
 
-		return EmitPointerBitCast(insn.resultId(), src, state);
+		return EmitBitcastPointer(insn.resultId(), src);
 	}
 
-	auto &dst = state->createIntermediate(insn.resultId(), type.componentCount);
+	auto &dst = createIntermediate(insn.resultId(), type.componentCount);
 
 	for(auto i = 0u; i < type.componentCount; i++)
 	{
@@ -215,9 +215,9 @@
 			break;
 		case spv::OpBitFieldInsert:
 			{
-				auto insert = Operand(this, state, insn.word(4)).UInt(i);
-				auto offset = Operand(this, state, insn.word(5)).UInt(0);
-				auto count = Operand(this, state, insn.word(6)).UInt(0);
+				auto insert = Operand(shader, *this, insn.word(4)).UInt(i);
+				auto offset = Operand(shader, *this, insn.word(5)).UInt(0);
+				auto count = Operand(shader, *this, insn.word(6)).UInt(0);
 				auto one = SIMD::UInt(1);
 				auto v = src.UInt(i);
 				auto mask = Bitmask32(offset + count) ^ Bitmask32(offset);
@@ -227,8 +227,8 @@
 		case spv::OpBitFieldSExtract:
 		case spv::OpBitFieldUExtract:
 			{
-				auto offset = Operand(this, state, insn.word(4)).UInt(0);
-				auto count = Operand(this, state, insn.word(5)).UInt(0);
+				auto offset = Operand(shader, *this, insn.word(4)).UInt(0);
+				auto count = Operand(shader, *this, insn.word(5)).UInt(0);
 				auto one = SIMD::UInt(1);
 				auto v = src.UInt(i);
 				SIMD::UInt out = (v >> offset) & Bitmask32(count);
@@ -361,13 +361,13 @@
 	return EmitResult::Continue;
 }
 
-SpirvShader::EmitResult SpirvShader::EmitBinaryOp(InsnIterator insn, EmitState *state) const
+SpirvShader::EmitResult SpirvShader::EmitState::EmitBinaryOp(InsnIterator insn)
 {
-	auto &type = getType(insn.resultTypeId());
-	auto &dst = state->createIntermediate(insn.resultId(), type.componentCount);
-	auto &lhsType = getObjectType(insn.word(3));
-	auto lhs = Operand(this, state, insn.word(3));
-	auto rhs = Operand(this, state, insn.word(4));
+	auto &type = shader.getType(insn.resultTypeId());
+	auto &dst = createIntermediate(insn.resultId(), type.componentCount);
+	auto &lhsType = shader.getObjectType(insn.word(3));
+	auto lhs = Operand(shader, *this, insn.word(3));
+	auto rhs = Operand(shader, *this, insn.word(4));
 
 	for(auto i = 0u; i < lhsType.componentCount; i++)
 	{
@@ -574,14 +574,14 @@
 	return EmitResult::Continue;
 }
 
-SpirvShader::EmitResult SpirvShader::EmitDot(InsnIterator insn, EmitState *state) const
+SpirvShader::EmitResult SpirvShader::EmitState::EmitDot(InsnIterator insn)
 {
-	auto &type = getType(insn.resultTypeId());
+	auto &type = shader.getType(insn.resultTypeId());
 	ASSERT(type.componentCount == 1);
-	auto &dst = state->createIntermediate(insn.resultId(), type.componentCount);
-	auto &lhsType = getObjectType(insn.word(3));
-	auto lhs = Operand(this, state, insn.word(3));
-	auto rhs = Operand(this, state, insn.word(4));
+	auto &dst = createIntermediate(insn.resultId(), type.componentCount);
+	auto &lhsType = shader.getObjectType(insn.word(3));
+	auto lhs = Operand(shader, *this, insn.word(3));
+	auto rhs = Operand(shader, *this, insn.word(4));
 
 	auto opcode = insn.opcode();
 	switch(opcode)
@@ -600,19 +600,19 @@
 		break;
 	case spv::OpSDotAccSat:
 		{
-			auto accum = Operand(this, state, insn.word(5));
+			auto accum = Operand(shader, *this, insn.word(5));
 			dst.move(0, SDot(lhsType.componentCount, lhs, rhs, &accum));
 		}
 		break;
 	case spv::OpUDotAccSat:
 		{
-			auto accum = Operand(this, state, insn.word(5));
+			auto accum = Operand(shader, *this, insn.word(5));
 			dst.move(0, UDot(lhsType.componentCount, lhs, rhs, &accum));
 		}
 		break;
 	case spv::OpSUDotAccSat:
 		{
-			auto accum = Operand(this, state, insn.word(5));
+			auto accum = Operand(shader, *this, insn.word(5));
 			dst.move(0, SUDot(lhsType.componentCount, lhs, rhs, &accum));
 		}
 		break;
@@ -628,7 +628,7 @@
 	return EmitResult::Continue;
 }
 
-SIMD::Float SpirvShader::FDot(unsigned numComponents, const Operand &x, const Operand &y)
+SIMD::Float SpirvShader::EmitState::FDot(unsigned numComponents, const Operand &x, const Operand &y)
 {
 	SIMD::Float d = x.Float(0) * y.Float(0);
 
@@ -640,7 +640,7 @@
 	return d;
 }
 
-SIMD::Int SpirvShader::SDot(unsigned numComponents, const Operand &x, const Operand &y, const Operand *accum)
+SIMD::Int SpirvShader::EmitState::SDot(unsigned numComponents, const Operand &x, const Operand &y, const Operand *accum)
 {
 	SIMD::Int d(0);
 
@@ -676,7 +676,7 @@
 	return d;
 }
 
-SIMD::UInt SpirvShader::UDot(unsigned numComponents, const Operand &x, const Operand &y, const Operand *accum)
+SIMD::UInt SpirvShader::EmitState::UDot(unsigned numComponents, const Operand &x, const Operand &y, const Operand *accum)
 {
 	SIMD::UInt d(0);
 
@@ -712,7 +712,7 @@
 	return d;
 }
 
-SIMD::Int SpirvShader::SUDot(unsigned numComponents, const Operand &x, const Operand &y, const Operand *accum)
+SIMD::Int SpirvShader::EmitState::SUDot(unsigned numComponents, const Operand &x, const Operand &y, const Operand *accum)
 {
 	SIMD::Int d(0);
 
@@ -748,7 +748,7 @@
 	return d;
 }
 
-SIMD::Int SpirvShader::AddSat(RValue<SIMD::Int> a, RValue<SIMD::Int> b)
+SIMD::Int SpirvShader::EmitState::AddSat(RValue<SIMD::Int> a, RValue<SIMD::Int> b)
 {
 	SIMD::Int sum = a + b;
 	SIMD::Int sSign = sum >> 31;
@@ -765,7 +765,7 @@
 	       (~oob & sum);
 }
 
-SIMD::UInt SpirvShader::AddSat(RValue<SIMD::UInt> a, RValue<SIMD::UInt> b)
+SIMD::UInt SpirvShader::EmitState::AddSat(RValue<SIMD::UInt> a, RValue<SIMD::UInt> b)
 {
 	SIMD::UInt sum = a + b;
 
diff --git a/src/Pipeline/SpirvShaderControlFlow.cpp b/src/Pipeline/SpirvShaderControlFlow.cpp
index 4d84ebc..e19f1b3 100644
--- a/src/Pipeline/SpirvShaderControlFlow.cpp
+++ b/src/Pipeline/SpirvShaderControlFlow.cpp
@@ -216,21 +216,21 @@
 	}
 }
 
-RValue<SIMD::Int> SpirvShader::GetActiveLaneMaskEdge(EmitState *state, Block::ID from, Block::ID to) const
+RValue<SIMD::Int> SpirvShader::EmitState::GetActiveLaneMaskEdge(Block::ID from, Block::ID to) const
 {
 	auto edge = Block::Edge{ from, to };
-	auto it = state->edgeActiveLaneMasks.find(edge);
-	ASSERT_MSG(it != state->edgeActiveLaneMasks.end(), "Could not find edge %d -> %d", from.value(), to.value());
+	auto it = edgeActiveLaneMasks.find(edge);
+	ASSERT_MSG(it != edgeActiveLaneMasks.end(), "Could not find edge %d -> %d", from.value(), to.value());
 	return it->second;
 }
 
-void SpirvShader::EmitBlocks(Block::ID id, EmitState *state, Block::ID ignore /* = 0 */) const
+void SpirvShader::EmitState::EmitBlocks(Block::ID id, Block::ID ignore /* = 0 */)
 {
-	auto oldPending = state->pending;
-	auto &function = getFunction(state->function);
+	auto oldPending = this->pending;
+	auto &function = shader.getFunction(this->function);
 
 	std::deque<Block::ID> pending;
-	state->pending = &pending;
+	this->pending = &pending;
 	pending.push_front(id);
 	while(pending.size() > 0)
 	{
@@ -246,9 +246,9 @@
 		// Ensure all dependency blocks have been generated.
 		auto depsDone = true;
 		function.ForeachBlockDependency(id, [&](Block::ID dep) {
-			if(state->visited.count(dep) == 0)
+			if(visited.count(dep) == 0)
 			{
-				state->pending->push_front(dep);
+				this->pending->push_front(dep);
 				depsDone = false;
 			}
 		});
@@ -260,7 +260,7 @@
 
 		pending.pop_front();
 
-		state->block = id;
+		this->block = id;
 
 		switch(block.kind)
 		{
@@ -269,11 +269,11 @@
 		case Block::UnstructuredBranchConditional:
 		case Block::StructuredSwitch:
 		case Block::UnstructuredSwitch:
-			EmitNonLoop(state);
+			EmitNonLoop();
 			break;
 
 		case Block::Loop:
-			EmitLoop(state);
+			EmitLoop();
 			break;
 
 		default:
@@ -281,16 +281,16 @@
 		}
 	}
 
-	state->pending = oldPending;
+	this->pending = oldPending;
 }
 
-void SpirvShader::EmitNonLoop(EmitState *state) const
+void SpirvShader::EmitState::EmitNonLoop()
 {
-	auto &function = getFunction(state->function);
-	auto blockId = state->block;
+	auto &function = shader.getFunction(this->function);
+	auto blockId = block;
 	auto block = function.getBlock(blockId);
 
-	if(!state->visited.emplace(blockId).second)
+	if(!visited.emplace(blockId).second)
 	{
 		return;  // Already generated this block.
 	}
@@ -301,36 +301,36 @@
 		SIMD::Int activeLaneMask(0);
 		for(auto in : block.ins)
 		{
-			auto inMask = GetActiveLaneMaskEdge(state, in, blockId);
+			auto inMask = GetActiveLaneMaskEdge(in, blockId);
 			SPIRV_SHADER_DBG("Block {0} -> {1} mask: {2}", in, blockId, inMask);
 			activeLaneMask |= inMask;
 		}
 		SPIRV_SHADER_DBG("Block {0} mask: {1}", blockId, activeLaneMask);
-		SetActiveLaneMask(activeLaneMask, state);
+		SetActiveLaneMask(activeLaneMask);
 	}
 
-	EmitInstructions(block.begin(), block.end(), state);
+	EmitInstructions(block.begin(), block.end());
 
 	for(auto out : block.outs)
 	{
-		if(state->visited.count(out) == 0)
+		if(visited.count(out) == 0)
 		{
-			state->pending->push_back(out);
+			pending->push_back(out);
 		}
 	}
 
 	SPIRV_SHADER_DBG("Block {0} done", blockId);
 }
 
-void SpirvShader::EmitLoop(EmitState *state) const
+void SpirvShader::EmitState::EmitLoop()
 {
-	auto &function = getFunction(state->function);
-	auto blockId = state->block;
+	auto &function = shader.getFunction(this->function);
+	auto blockId = block;
 	auto &block = function.getBlock(blockId);
 	auto mergeBlockId = block.mergeBlock;
 	auto &mergeBlock = function.getBlock(mergeBlockId);
 
-	if(!state->visited.emplace(blockId).second)
+	if(!visited.emplace(blockId).second)
 	{
 		return;  // Already emitted this loop.
 	}
@@ -358,7 +358,7 @@
 	{
 		if(insn.opcode() == spv::OpPhi)
 		{
-			StorePhi(blockId, insn, state, incomingBlocks);
+			StorePhi(blockId, insn, incomingBlocks);
 		}
 	}
 
@@ -367,7 +367,7 @@
 	SIMD::Int loopActiveLaneMask = SIMD::Int(0);
 	for(auto in : incomingBlocks)
 	{
-		loopActiveLaneMask |= GetActiveLaneMaskEdge(state, in, blockId);
+		loopActiveLaneMask |= GetActiveLaneMaskEdge(in, blockId);
 	}
 
 	// mergeActiveLaneMasks contains edge lane masks for the merge block.
@@ -389,18 +389,18 @@
 	SPIRV_SHADER_DBG("*** LOOP START (mask: {0}) ***", loopActiveLaneMask);
 
 	// Load the active lane mask.
-	SetActiveLaneMask(loopActiveLaneMask, state);
+	SetActiveLaneMask(loopActiveLaneMask);
 
 	// Emit the non-phi loop header block's instructions.
 	for(auto insn = block.begin(); insn != block.end(); insn++)
 	{
 		if(insn.opcode() == spv::OpPhi)
 		{
-			LoadPhi(insn, state);
+			LoadPhi(insn);
 		}
 		else
 		{
-			EmitInstruction(insn, state);
+			EmitInstruction(insn);
 		}
 	}
 
@@ -408,11 +408,11 @@
 	// don't emit the merge block yet.
 	for(auto out : block.outs)
 	{
-		EmitBlocks(out, state, mergeBlockId);
+		EmitBlocks(out, mergeBlockId);
 	}
 
 	// Restore current block id after emitting loop blocks.
-	state->block = blockId;
+	this->block = blockId;
 
 	// Rebuild the loopActiveLaneMask from the loop back edges.
 	loopActiveLaneMask = SIMD::Int(0);
@@ -420,7 +420,7 @@
 	{
 		if(function.ExistsPath(blockId, in, mergeBlockId))
 		{
-			loopActiveLaneMask |= GetActiveLaneMaskEdge(state, in, blockId);
+			loopActiveLaneMask |= GetActiveLaneMaskEdge(in, blockId);
 		}
 	}
 
@@ -428,8 +428,8 @@
 	for(auto in : function.getBlock(mergeBlockId).ins)
 	{
 		auto edge = Block::Edge{ in, mergeBlockId };
-		auto it = state->edgeActiveLaneMasks.find(edge);
-		if(it != state->edgeActiveLaneMasks.end())
+		auto it = edgeActiveLaneMasks.find(edge);
+		if(it != edgeActiveLaneMasks.end())
 		{
 			mergeActiveLaneMasks[in] |= it->second;
 		}
@@ -440,7 +440,7 @@
 	{
 		if(insn.opcode() == spv::OpPhi)
 		{
-			StorePhi(blockId, insn, state, loopBlocks);
+			StorePhi(blockId, insn, loopBlocks);
 		}
 	}
 
@@ -474,7 +474,7 @@
 	{
 		if(insn.opcode() == spv::OpPhi)
 		{
-			StorePhi(mergeBlockId, insn, state, loopBlocks);
+			StorePhi(mergeBlockId, insn, loopBlocks);
 		}
 	}
 
@@ -485,50 +485,50 @@
 
 	// Continue emitting from the merge block.
 	Nucleus::setInsertBlock(mergeBasicBlock);
-	state->pending->push_back(mergeBlockId);
+	pending->push_back(mergeBlockId);
 	for(const auto &it : mergeActiveLaneMasks)
 	{
-		state->addActiveLaneMaskEdge(it.first, mergeBlockId, it.second);
+		addActiveLaneMaskEdge(it.first, mergeBlockId, it.second);
 	}
 }
 
-SpirvShader::EmitResult SpirvShader::EmitBranch(InsnIterator insn, EmitState *state) const
+SpirvShader::EmitResult SpirvShader::EmitState::EmitBranch(InsnIterator insn)
 {
 	auto target = Block::ID(insn.word(1));
-	state->addActiveLaneMaskEdge(state->block, target, state->activeLaneMask());
+	addActiveLaneMaskEdge(block, target, activeLaneMask());
 	return EmitResult::Terminator;
 }
 
-SpirvShader::EmitResult SpirvShader::EmitBranchConditional(InsnIterator insn, EmitState *state) const
+SpirvShader::EmitResult SpirvShader::EmitState::EmitBranchConditional(InsnIterator insn)
 {
-	auto &function = getFunction(state->function);
-	auto block = function.getBlock(state->block);
+	auto &function = shader.getFunction(this->function);
+	auto block = function.getBlock(this->block);
 	ASSERT(block.branchInstruction == insn);
 
 	auto condId = Object::ID(block.branchInstruction.word(1));
 	auto trueBlockId = Block::ID(block.branchInstruction.word(2));
 	auto falseBlockId = Block::ID(block.branchInstruction.word(3));
 
-	auto cond = Operand(this, state, condId);
-	ASSERT_MSG(getObjectType(condId).componentCount == 1, "Condition must be a Boolean type scalar");
+	auto cond = Operand(shader, *this, condId);
+	ASSERT_MSG(shader.getObjectType(condId).componentCount == 1, "Condition must be a Boolean type scalar");
 
 	// TODO: Optimize for case where all lanes take same path.
 
-	state->addOutputActiveLaneMaskEdge(trueBlockId, cond.Int(0));
-	state->addOutputActiveLaneMaskEdge(falseBlockId, ~cond.Int(0));
+	addOutputActiveLaneMaskEdge(trueBlockId, cond.Int(0));
+	addOutputActiveLaneMaskEdge(falseBlockId, ~cond.Int(0));
 
 	return EmitResult::Terminator;
 }
 
-SpirvShader::EmitResult SpirvShader::EmitSwitch(InsnIterator insn, EmitState *state) const
+SpirvShader::EmitResult SpirvShader::EmitState::EmitSwitch(InsnIterator insn)
 {
-	auto &function = getFunction(state->function);
-	auto block = function.getBlock(state->block);
+	auto &function = shader.getFunction(this->function);
+	auto block = function.getBlock(this->block);
 	ASSERT(block.branchInstruction == insn);
 
 	auto selId = Object::ID(block.branchInstruction.word(1));
 
-	auto sel = Operand(this, state, selId);
+	auto sel = Operand(shader, *this, selId);
 	ASSERT_MSG(sel.componentCount == 1, "Selector must be a scalar");
 	SPIRV_SHADER_DBG("switch({0})", sel);
 
@@ -536,7 +536,7 @@
 
 	// TODO: Optimize for case where all lanes take same path.
 
-	SIMD::Int defaultLaneMask = state->activeLaneMask();
+	SIMD::Int defaultLaneMask = activeLaneMask();
 
 	// Gather up the case label matches and calculate defaultLaneMask.
 	std::vector<RValue<SIMD::Int>> caseLabelMatches;
@@ -546,59 +546,59 @@
 		auto label = block.branchInstruction.word(i * 2 + 3);
 		auto caseBlockId = Block::ID(block.branchInstruction.word(i * 2 + 4));
 		auto caseLabelMatch = CmpEQ(sel.Int(0), SIMD::Int(label));
-		SPIRV_SHADER_DBG("case {0}: {1}", label, caseLabelMatch & state->activeLaneMask());
-		state->addOutputActiveLaneMaskEdge(caseBlockId, caseLabelMatch);
+		SPIRV_SHADER_DBG("case {0}: {1}", label, caseLabelMatch & activeLaneMask());
+		addOutputActiveLaneMaskEdge(caseBlockId, caseLabelMatch);
 		defaultLaneMask &= ~caseLabelMatch;
 	}
 
 	auto defaultBlockId = Block::ID(block.branchInstruction.word(2));
 	SPIRV_SHADER_DBG("default: {0}", defaultLaneMask);
-	state->addOutputActiveLaneMaskEdge(defaultBlockId, defaultLaneMask);
+	addOutputActiveLaneMaskEdge(defaultBlockId, defaultLaneMask);
 
 	return EmitResult::Terminator;
 }
 
-SpirvShader::EmitResult SpirvShader::EmitUnreachable(InsnIterator insn, EmitState *state) const
+SpirvShader::EmitResult SpirvShader::EmitState::EmitUnreachable(InsnIterator insn)
 {
 	// TODO: Log something in this case?
-	SetActiveLaneMask(SIMD::Int(0), state);
+	SetActiveLaneMask(SIMD::Int(0));
 	return EmitResult::Terminator;
 }
 
-SpirvShader::EmitResult SpirvShader::EmitReturn(InsnIterator insn, EmitState *state) const
+SpirvShader::EmitResult SpirvShader::EmitState::EmitReturn(InsnIterator insn)
 {
-	SetActiveLaneMask(SIMD::Int(0), state);
+	SetActiveLaneMask(SIMD::Int(0));
 	return EmitResult::Terminator;
 }
 
-SpirvShader::EmitResult SpirvShader::EmitTerminateInvocation(InsnIterator insn, EmitState *state) const
+SpirvShader::EmitResult SpirvShader::EmitState::EmitTerminateInvocation(InsnIterator insn)
 {
-	state->routine->discardMask |= SignMask(state->activeLaneMask());
-	SetActiveLaneMask(SIMD::Int(0), state);
+	routine->discardMask |= SignMask(activeLaneMask());
+	SetActiveLaneMask(SIMD::Int(0));
 	return EmitResult::Terminator;
 }
 
-SpirvShader::EmitResult SpirvShader::EmitDemoteToHelperInvocation(InsnIterator insn, EmitState *state) const
+SpirvShader::EmitResult SpirvShader::EmitState::EmitDemoteToHelperInvocation(InsnIterator insn)
 {
-	state->routine->helperInvocation |= state->activeLaneMask();
-	state->routine->discardMask |= SignMask(state->activeLaneMask());
-	SetStoresAndAtomicsMask(state->storesAndAtomicsMask() & ~state->activeLaneMask(), state);
+	routine->helperInvocation |= activeLaneMask();
+	routine->discardMask |= SignMask(activeLaneMask());
+	SetStoresAndAtomicsMask(storesAndAtomicsMask() & ~activeLaneMask());
 	return EmitResult::Continue;
 }
 
-SpirvShader::EmitResult SpirvShader::EmitIsHelperInvocation(InsnIterator insn, EmitState *state) const
+SpirvShader::EmitResult SpirvShader::EmitState::EmitIsHelperInvocation(InsnIterator insn)
 {
-	auto &type = getType(insn.resultTypeId());
-	auto &dst = state->createIntermediate(insn.resultId(), type.componentCount);
-	dst.move(0, state->routine->helperInvocation);
+	auto &type = shader.getType(insn.resultTypeId());
+	auto &dst = createIntermediate(insn.resultId(), type.componentCount);
+	dst.move(0, routine->helperInvocation);
 	return EmitResult::Continue;
 }
 
-SpirvShader::EmitResult SpirvShader::EmitFunctionCall(InsnIterator insn, EmitState *state) const
+SpirvShader::EmitResult SpirvShader::EmitState::EmitFunctionCall(InsnIterator insn)
 {
 	auto functionId = Function::ID(insn.word(3));
-	const auto &functionIt = functions.find(functionId);
-	ASSERT(functionIt != functions.end());
+	const auto &functionIt = shader.functions.find(functionId);
+	ASSERT(functionIt != shader.functions.end());
 	auto &function = functionIt->second;
 
 	// TODO(b/141246700): Add full support for spv::OpFunctionCall
@@ -626,7 +626,7 @@
 
 			if(blockInsn.opcode() == spv::OpKill)
 			{
-				EmitInstruction(blockInsn, state);
+				EmitInstruction(blockInsn);
 			}
 		}
 	}
@@ -634,10 +634,10 @@
 	return EmitResult::Continue;
 }
 
-SpirvShader::EmitResult SpirvShader::EmitControlBarrier(InsnIterator insn, EmitState *state) const
+SpirvShader::EmitResult SpirvShader::EmitState::EmitControlBarrier(InsnIterator insn) const
 {
-	auto executionScope = spv::Scope(GetConstScalarInt(insn.word(1)));
-	auto semantics = spv::MemorySemanticsMask(GetConstScalarInt(insn.word(3)));
+	auto executionScope = spv::Scope(shader.GetConstScalarInt(insn.word(1)));
+	auto semantics = spv::MemorySemanticsMask(shader.GetConstScalarInt(insn.word(3)));
 	// TODO(b/176819536): We probably want to consider the memory scope here.
 	// For now, just always emit the full fence.
 	Fence(semantics);
@@ -658,32 +658,32 @@
 	return EmitResult::Continue;
 }
 
-SpirvShader::EmitResult SpirvShader::EmitPhi(InsnIterator insn, EmitState *state) const
+SpirvShader::EmitResult SpirvShader::EmitState::EmitPhi(InsnIterator insn)
 {
-	auto &function = getFunction(state->function);
-	auto currentBlock = function.getBlock(state->block);
+	auto &function = shader.getFunction(this->function);
+	auto currentBlock = function.getBlock(block);
 	if(!currentBlock.isLoopMerge)
 	{
 		// If this is a loop merge block, then don't attempt to update the
 		// phi values from the ins. EmitLoop() has had to take special care
 		// of this phi in order to correctly deal with divergent lanes.
-		StorePhi(state->block, insn, state, currentBlock.ins);
+		StorePhi(block, insn, currentBlock.ins);
 	}
-	LoadPhi(insn, state);
+	LoadPhi(insn);
 	return EmitResult::Continue;
 }
 
-void SpirvShader::LoadPhi(InsnIterator insn, EmitState *state) const
+void SpirvShader::EmitState::LoadPhi(InsnIterator insn)
 {
 	auto typeId = Type::ID(insn.word(1));
-	auto type = getType(typeId);
+	auto type = shader.getType(typeId);
 	auto objectId = Object::ID(insn.word(2));
 
-	auto storageIt = state->routine->phis.find(objectId);
-	ASSERT(storageIt != state->routine->phis.end());
+	auto storageIt = routine->phis.find(objectId);
+	ASSERT(storageIt != routine->phis.end());
 	auto &storage = storageIt->second;
 
-	auto &dst = state->createIntermediate(objectId, type.componentCount);
+	auto &dst = createIntermediate(objectId, type.componentCount);
 	for(uint32_t i = 0; i < type.componentCount; i++)
 	{
 		dst.move(i, storage[i]);
@@ -691,14 +691,14 @@
 	}
 }
 
-void SpirvShader::StorePhi(Block::ID currentBlock, InsnIterator insn, EmitState *state, const std::unordered_set<SpirvShader::Block::ID> &filter) const
+void SpirvShader::EmitState::StorePhi(Block::ID currentBlock, InsnIterator insn, const std::unordered_set<SpirvShader::Block::ID> &filter) const
 {
 	auto typeId = Type::ID(insn.word(1));
-	auto type = getType(typeId);
+	auto type = shader.getType(typeId);
 	auto objectId = Object::ID(insn.word(2));
 
-	auto storageIt = state->routine->phis.find(objectId);
-	ASSERT(storageIt != state->routine->phis.end());
+	auto storageIt = routine->phis.find(objectId);
+	ASSERT(storageIt != routine->phis.end());
 	auto &storage = storageIt->second;
 
 	for(uint32_t w = 3; w < insn.wordCount(); w += 2)
@@ -711,8 +711,8 @@
 			continue;
 		}
 
-		auto mask = GetActiveLaneMaskEdge(state, blockId, currentBlock);
-		auto in = Operand(this, state, varId);
+		auto mask = GetActiveLaneMaskEdge(blockId, currentBlock);
+		auto in = Operand(shader, *this, varId);
 
 		for(uint32_t i = 0; i < type.componentCount; i++)
 		{
@@ -728,19 +728,19 @@
 	}
 }
 
-void SpirvShader::Yield(YieldResult res) const
+void SpirvShader::EmitState::Yield(YieldResult res) const
 {
 	rr::Yield(RValue<Int>(int(res)));
 }
 
-void SpirvShader::SetActiveLaneMask(RValue<SIMD::Int> mask, EmitState *state) const
+void SpirvShader::EmitState::SetActiveLaneMask(RValue<SIMD::Int> mask)
 {
-	state->activeLaneMaskValue = mask.value();
+	activeLaneMaskValue = mask.value();
 }
 
-void SpirvShader::SetStoresAndAtomicsMask(RValue<SIMD::Int> mask, EmitState *state) const
+void SpirvShader::EmitState::SetStoresAndAtomicsMask(RValue<SIMD::Int> mask)
 {
-	state->storesAndAtomicsMaskValue = mask.value();
+	storesAndAtomicsMaskValue = mask.value();
 }
 
 void SpirvShader::WriteCFGGraphVizDotFile(const char *path) const
diff --git a/src/Pipeline/SpirvShaderGLSLstd450.cpp b/src/Pipeline/SpirvShaderGLSLstd450.cpp
index 61c2e42..672afd8 100644
--- a/src/Pipeline/SpirvShaderGLSLstd450.cpp
+++ b/src/Pipeline/SpirvShaderGLSLstd450.cpp
@@ -25,17 +25,17 @@
 
 static constexpr float PI = 3.141592653589793f;
 
-SpirvShader::EmitResult SpirvShader::EmitExtGLSLstd450(InsnIterator insn, EmitState *state) const
+SpirvShader::EmitResult SpirvShader::EmitState::EmitExtGLSLstd450(InsnIterator insn)
 {
-	auto &type = getType(insn.resultTypeId());
-	auto &dst = state->createIntermediate(insn.resultId(), type.componentCount);
+	auto &type = shader.getType(insn.resultTypeId());
+	auto &dst = createIntermediate(insn.resultId(), type.componentCount);
 	auto extInstIndex = static_cast<GLSLstd450>(insn.word(4));
 
 	switch(extInstIndex)
 	{
 	case GLSLstd450FAbs:
 		{
-			auto src = Operand(this, state, insn.word(5));
+			auto src = Operand(shader, *this, insn.word(5));
 			for(auto i = 0u; i < type.componentCount; i++)
 			{
 				dst.move(i, Abs(src.Float(i)));
@@ -44,7 +44,7 @@
 		break;
 	case GLSLstd450SAbs:
 		{
-			auto src = Operand(this, state, insn.word(5));
+			auto src = Operand(shader, *this, insn.word(5));
 			for(auto i = 0u; i < type.componentCount; i++)
 			{
 				dst.move(i, Abs(src.Int(i)));
@@ -53,8 +53,8 @@
 		break;
 	case GLSLstd450Cross:
 		{
-			auto lhs = Operand(this, state, insn.word(5));
-			auto rhs = Operand(this, state, insn.word(6));
+			auto lhs = Operand(shader, *this, insn.word(5));
+			auto rhs = Operand(shader, *this, insn.word(6));
 			dst.move(0, lhs.Float(1) * rhs.Float(2) - rhs.Float(1) * lhs.Float(2));
 			dst.move(1, lhs.Float(2) * rhs.Float(0) - rhs.Float(2) * lhs.Float(0));
 			dst.move(2, lhs.Float(0) * rhs.Float(1) - rhs.Float(0) * lhs.Float(1));
@@ -62,7 +62,7 @@
 		break;
 	case GLSLstd450Floor:
 		{
-			auto src = Operand(this, state, insn.word(5));
+			auto src = Operand(shader, *this, insn.word(5));
 			for(auto i = 0u; i < type.componentCount; i++)
 			{
 				dst.move(i, Floor(src.Float(i)));
@@ -71,7 +71,7 @@
 		break;
 	case GLSLstd450Trunc:
 		{
-			auto src = Operand(this, state, insn.word(5));
+			auto src = Operand(shader, *this, insn.word(5));
 			for(auto i = 0u; i < type.componentCount; i++)
 			{
 				dst.move(i, Trunc(src.Float(i)));
@@ -80,7 +80,7 @@
 		break;
 	case GLSLstd450Ceil:
 		{
-			auto src = Operand(this, state, insn.word(5));
+			auto src = Operand(shader, *this, insn.word(5));
 			for(auto i = 0u; i < type.componentCount; i++)
 			{
 				dst.move(i, Ceil(src.Float(i)));
@@ -89,7 +89,7 @@
 		break;
 	case GLSLstd450Fract:
 		{
-			auto src = Operand(this, state, insn.word(5));
+			auto src = Operand(shader, *this, insn.word(5));
 			for(auto i = 0u; i < type.componentCount; i++)
 			{
 				dst.move(i, Frac(src.Float(i)));
@@ -98,7 +98,7 @@
 		break;
 	case GLSLstd450Round:
 		{
-			auto src = Operand(this, state, insn.word(5));
+			auto src = Operand(shader, *this, insn.word(5));
 			for(auto i = 0u; i < type.componentCount; i++)
 			{
 				dst.move(i, Round(src.Float(i)));
@@ -107,7 +107,7 @@
 		break;
 	case GLSLstd450RoundEven:
 		{
-			auto src = Operand(this, state, insn.word(5));
+			auto src = Operand(shader, *this, insn.word(5));
 			for(auto i = 0u; i < type.componentCount; i++)
 			{
 				auto x = Round(src.Float(i));
@@ -119,8 +119,8 @@
 		break;
 	case GLSLstd450FMin:
 		{
-			auto lhs = Operand(this, state, insn.word(5));
-			auto rhs = Operand(this, state, insn.word(6));
+			auto lhs = Operand(shader, *this, insn.word(5));
+			auto rhs = Operand(shader, *this, insn.word(6));
 			for(auto i = 0u; i < type.componentCount; i++)
 			{
 				dst.move(i, Min(lhs.Float(i), rhs.Float(i)));
@@ -129,8 +129,8 @@
 		break;
 	case GLSLstd450FMax:
 		{
-			auto lhs = Operand(this, state, insn.word(5));
-			auto rhs = Operand(this, state, insn.word(6));
+			auto lhs = Operand(shader, *this, insn.word(5));
+			auto rhs = Operand(shader, *this, insn.word(6));
 			for(auto i = 0u; i < type.componentCount; i++)
 			{
 				dst.move(i, Max(lhs.Float(i), rhs.Float(i)));
@@ -139,8 +139,8 @@
 		break;
 	case GLSLstd450SMin:
 		{
-			auto lhs = Operand(this, state, insn.word(5));
-			auto rhs = Operand(this, state, insn.word(6));
+			auto lhs = Operand(shader, *this, insn.word(5));
+			auto rhs = Operand(shader, *this, insn.word(6));
 			for(auto i = 0u; i < type.componentCount; i++)
 			{
 				dst.move(i, Min(lhs.Int(i), rhs.Int(i)));
@@ -149,8 +149,8 @@
 		break;
 	case GLSLstd450SMax:
 		{
-			auto lhs = Operand(this, state, insn.word(5));
-			auto rhs = Operand(this, state, insn.word(6));
+			auto lhs = Operand(shader, *this, insn.word(5));
+			auto rhs = Operand(shader, *this, insn.word(6));
 			for(auto i = 0u; i < type.componentCount; i++)
 			{
 				dst.move(i, Max(lhs.Int(i), rhs.Int(i)));
@@ -159,8 +159,8 @@
 		break;
 	case GLSLstd450UMin:
 		{
-			auto lhs = Operand(this, state, insn.word(5));
-			auto rhs = Operand(this, state, insn.word(6));
+			auto lhs = Operand(shader, *this, insn.word(5));
+			auto rhs = Operand(shader, *this, insn.word(6));
 			for(auto i = 0u; i < type.componentCount; i++)
 			{
 				dst.move(i, Min(lhs.UInt(i), rhs.UInt(i)));
@@ -169,8 +169,8 @@
 		break;
 	case GLSLstd450UMax:
 		{
-			auto lhs = Operand(this, state, insn.word(5));
-			auto rhs = Operand(this, state, insn.word(6));
+			auto lhs = Operand(shader, *this, insn.word(5));
+			auto rhs = Operand(shader, *this, insn.word(6));
 			for(auto i = 0u; i < type.componentCount; i++)
 			{
 				dst.move(i, Max(lhs.UInt(i), rhs.UInt(i)));
@@ -179,8 +179,8 @@
 		break;
 	case GLSLstd450Step:
 		{
-			auto edge = Operand(this, state, insn.word(5));
-			auto x = Operand(this, state, insn.word(6));
+			auto edge = Operand(shader, *this, insn.word(5));
+			auto x = Operand(shader, *this, insn.word(6));
 			for(auto i = 0u; i < type.componentCount; i++)
 			{
 				dst.move(i, CmpNLT(x.Float(i), edge.Float(i)) & As<SIMD::Int>(SIMD::Float(1.0f)));
@@ -189,9 +189,9 @@
 		break;
 	case GLSLstd450SmoothStep:
 		{
-			auto edge0 = Operand(this, state, insn.word(5));
-			auto edge1 = Operand(this, state, insn.word(6));
-			auto x = Operand(this, state, insn.word(7));
+			auto edge0 = Operand(shader, *this, insn.word(5));
+			auto edge1 = Operand(shader, *this, insn.word(6));
+			auto x = Operand(shader, *this, insn.word(7));
 			for(auto i = 0u; i < type.componentCount; i++)
 			{
 				auto tx = Min(Max((x.Float(i) - edge0.Float(i)) / (edge1.Float(i) - edge0.Float(i)), 0.0f), 1.0f);
@@ -201,9 +201,9 @@
 		break;
 	case GLSLstd450FMix:
 		{
-			auto x = Operand(this, state, insn.word(5));
-			auto y = Operand(this, state, insn.word(6));
-			auto a = Operand(this, state, insn.word(7));
+			auto x = Operand(shader, *this, insn.word(5));
+			auto y = Operand(shader, *this, insn.word(6));
+			auto a = Operand(shader, *this, insn.word(7));
 			for(auto i = 0u; i < type.componentCount; i++)
 			{
 				dst.move(i, a.Float(i) * (y.Float(i) - x.Float(i)) + x.Float(i));
@@ -212,9 +212,9 @@
 		break;
 	case GLSLstd450FClamp:
 		{
-			auto x = Operand(this, state, insn.word(5));
-			auto minVal = Operand(this, state, insn.word(6));
-			auto maxVal = Operand(this, state, insn.word(7));
+			auto x = Operand(shader, *this, insn.word(5));
+			auto minVal = Operand(shader, *this, insn.word(6));
+			auto maxVal = Operand(shader, *this, insn.word(7));
 			for(auto i = 0u; i < type.componentCount; i++)
 			{
 				dst.move(i, Min(Max(x.Float(i), minVal.Float(i)), maxVal.Float(i)));
@@ -223,9 +223,9 @@
 		break;
 	case GLSLstd450SClamp:
 		{
-			auto x = Operand(this, state, insn.word(5));
-			auto minVal = Operand(this, state, insn.word(6));
-			auto maxVal = Operand(this, state, insn.word(7));
+			auto x = Operand(shader, *this, insn.word(5));
+			auto minVal = Operand(shader, *this, insn.word(6));
+			auto maxVal = Operand(shader, *this, insn.word(7));
 			for(auto i = 0u; i < type.componentCount; i++)
 			{
 				dst.move(i, Min(Max(x.Int(i), minVal.Int(i)), maxVal.Int(i)));
@@ -234,9 +234,9 @@
 		break;
 	case GLSLstd450UClamp:
 		{
-			auto x = Operand(this, state, insn.word(5));
-			auto minVal = Operand(this, state, insn.word(6));
-			auto maxVal = Operand(this, state, insn.word(7));
+			auto x = Operand(shader, *this, insn.word(5));
+			auto minVal = Operand(shader, *this, insn.word(6));
+			auto maxVal = Operand(shader, *this, insn.word(7));
 			for(auto i = 0u; i < type.componentCount; i++)
 			{
 				dst.move(i, Min(Max(x.UInt(i), minVal.UInt(i)), maxVal.UInt(i)));
@@ -245,7 +245,7 @@
 		break;
 	case GLSLstd450FSign:
 		{
-			auto src = Operand(this, state, insn.word(5));
+			auto src = Operand(shader, *this, insn.word(5));
 			for(auto i = 0u; i < type.componentCount; i++)
 			{
 				auto neg = As<SIMD::Int>(CmpLT(src.Float(i), SIMD::Float(-0.0f))) & As<SIMD::Int>(SIMD::Float(-1.0f));
@@ -256,7 +256,7 @@
 		break;
 	case GLSLstd450SSign:
 		{
-			auto src = Operand(this, state, insn.word(5));
+			auto src = Operand(shader, *this, insn.word(5));
 			for(auto i = 0u; i < type.componentCount; i++)
 			{
 				auto neg = CmpLT(src.Int(i), SIMD::Int(0)) & SIMD::Int(-1);
@@ -267,8 +267,8 @@
 		break;
 	case GLSLstd450Reflect:
 		{
-			auto I = Operand(this, state, insn.word(5));
-			auto N = Operand(this, state, insn.word(6));
+			auto I = Operand(shader, *this, insn.word(5));
+			auto N = Operand(shader, *this, insn.word(6));
 
 			SIMD::Float d = FDot(type.componentCount, I, N);
 
@@ -280,10 +280,10 @@
 		break;
 	case GLSLstd450Refract:
 		{
-			auto I = Operand(this, state, insn.word(5));
-			auto N = Operand(this, state, insn.word(6));
-			auto eta = Operand(this, state, insn.word(7));
-			Decorations r = GetDecorationsForId(insn.resultId());
+			auto I = Operand(shader, *this, insn.word(5));
+			auto N = Operand(shader, *this, insn.word(6));
+			auto eta = Operand(shader, *this, insn.word(7));
+			Decorations r = shader.GetDecorationsForId(insn.resultId());
 
 			SIMD::Float d = FDot(type.componentCount, I, N);
 			SIMD::Float k = SIMD::Float(1.0f) - eta.Float(0) * eta.Float(0) * (SIMD::Float(1.0f) - d * d);
@@ -298,9 +298,9 @@
 		break;
 	case GLSLstd450FaceForward:
 		{
-			auto N = Operand(this, state, insn.word(5));
-			auto I = Operand(this, state, insn.word(6));
-			auto Nref = Operand(this, state, insn.word(7));
+			auto N = Operand(shader, *this, insn.word(5));
+			auto I = Operand(shader, *this, insn.word(6));
+			auto Nref = Operand(shader, *this, insn.word(7));
 
 			SIMD::Float d = FDot(type.componentCount, I, Nref);
 			SIMD::Int neg = CmpLT(d, SIMD::Float(0.0f));
@@ -314,19 +314,19 @@
 		break;
 	case GLSLstd450Length:
 		{
-			auto x = Operand(this, state, insn.word(5));
-			SIMD::Float d = FDot(getObjectType(insn.word(5)).componentCount, x, x);
-			Decorations r = GetDecorationsForId(insn.resultId());
+			auto x = Operand(shader, *this, insn.word(5));
+			SIMD::Float d = FDot(shader.getObjectType(insn.word(5)).componentCount, x, x);
+			Decorations r = shader.GetDecorationsForId(insn.resultId());
 
 			dst.move(0, Sqrt(d, r.RelaxedPrecision));
 		}
 		break;
 	case GLSLstd450Normalize:
 		{
-			auto x = Operand(this, state, insn.word(5));
-			Decorations r = GetDecorationsForId(insn.resultId());
+			auto x = Operand(shader, *this, insn.word(5));
+			Decorations r = shader.GetDecorationsForId(insn.resultId());
 
-			SIMD::Float d = FDot(getObjectType(insn.word(5)).componentCount, x, x);
+			SIMD::Float d = FDot(shader.getObjectType(insn.word(5)).componentCount, x, x);
 			SIMD::Float invLength = SIMD::Float(1.0f) / Sqrt(d, r.RelaxedPrecision);
 
 			for(auto i = 0u; i < type.componentCount; i++)
@@ -337,9 +337,9 @@
 		break;
 	case GLSLstd450Distance:
 		{
-			auto p0 = Operand(this, state, insn.word(5));
-			auto p1 = Operand(this, state, insn.word(6));
-			Decorations r = GetDecorationsForId(insn.resultId());
+			auto p0 = Operand(shader, *this, insn.word(5));
+			auto p1 = Operand(shader, *this, insn.word(6));
+			Decorations r = shader.GetDecorationsForId(insn.resultId());
 
 			// sqrt(dot(p0-p1, p0-p1))
 			SIMD::Float d = (p0.Float(0) - p1.Float(0)) * (p0.Float(0) - p1.Float(0));
@@ -354,7 +354,7 @@
 		break;
 	case GLSLstd450Modf:
 		{
-			auto val = Operand(this, state, insn.word(5));
+			auto val = Operand(shader, *this, insn.word(5));
 			auto ptrId = Object::ID(insn.word(6));
 
 			Intermediate whole(type.componentCount);
@@ -366,12 +366,12 @@
 				whole.move(i, wholeAndFrac.first);
 			}
 
-			Store(ptrId, whole, false, std::memory_order_relaxed, state);
+			Store(ptrId, whole, false, std::memory_order_relaxed);
 		}
 		break;
 	case GLSLstd450ModfStruct:
 		{
-			auto val = Operand(this, state, insn.word(5));
+			auto val = Operand(shader, *this, insn.word(5));
 
 			for(auto i = 0u; i < val.componentCount; i++)
 			{
@@ -383,7 +383,7 @@
 		break;
 	case GLSLstd450PackSnorm4x8:
 		{
-			auto val = Operand(this, state, insn.word(5));
+			auto val = Operand(shader, *this, insn.word(5));
 			dst.move(0, (SIMD::Int(Round(Min(Max(val.Float(0), SIMD::Float(-1.0f)), SIMD::Float(1.0f)) * SIMD::Float(127.0f))) &
 			             SIMD::Int(0xFF)) |
 			                ((SIMD::Int(Round(Min(Max(val.Float(1), SIMD::Float(-1.0f)), SIMD::Float(1.0f)) * SIMD::Float(127.0f))) &
@@ -399,7 +399,7 @@
 		break;
 	case GLSLstd450PackUnorm4x8:
 		{
-			auto val = Operand(this, state, insn.word(5));
+			auto val = Operand(shader, *this, insn.word(5));
 			dst.move(0, (SIMD::UInt(Round(Min(Max(val.Float(0), SIMD::Float(0.0f)), SIMD::Float(1.0f)) * SIMD::Float(255.0f)))) |
 			                ((SIMD::UInt(Round(Min(Max(val.Float(1), SIMD::Float(0.0f)), SIMD::Float(1.0f)) * SIMD::Float(255.0f)))) << 8) |
 			                ((SIMD::UInt(Round(Min(Max(val.Float(2), SIMD::Float(0.0f)), SIMD::Float(1.0f)) * SIMD::Float(255.0f)))) << 16) |
@@ -408,7 +408,7 @@
 		break;
 	case GLSLstd450PackSnorm2x16:
 		{
-			auto val = Operand(this, state, insn.word(5));
+			auto val = Operand(shader, *this, insn.word(5));
 			dst.move(0, (SIMD::Int(Round(Min(Max(val.Float(0), SIMD::Float(-1.0f)), SIMD::Float(1.0f)) * SIMD::Float(32767.0f))) &
 			             SIMD::Int(0xFFFF)) |
 			                ((SIMD::Int(Round(Min(Max(val.Float(1), SIMD::Float(-1.0f)), SIMD::Float(1.0f)) * SIMD::Float(32767.0f))) &
@@ -418,7 +418,7 @@
 		break;
 	case GLSLstd450PackUnorm2x16:
 		{
-			auto val = Operand(this, state, insn.word(5));
+			auto val = Operand(shader, *this, insn.word(5));
 			dst.move(0, (SIMD::UInt(Round(Min(Max(val.Float(0), SIMD::Float(0.0f)), SIMD::Float(1.0f)) * SIMD::Float(65535.0f))) &
 			             SIMD::UInt(0xFFFF)) |
 			                ((SIMD::UInt(Round(Min(Max(val.Float(1), SIMD::Float(0.0f)), SIMD::Float(1.0f)) * SIMD::Float(65535.0f))) &
@@ -428,13 +428,13 @@
 		break;
 	case GLSLstd450PackHalf2x16:
 		{
-			auto val = Operand(this, state, insn.word(5));
+			auto val = Operand(shader, *this, insn.word(5));
 			dst.move(0, floatToHalfBits(val.UInt(0), false) | floatToHalfBits(val.UInt(1), true));
 		}
 		break;
 	case GLSLstd450UnpackSnorm4x8:
 		{
-			auto val = Operand(this, state, insn.word(5));
+			auto val = Operand(shader, *this, insn.word(5));
 			dst.move(0, Min(Max(SIMD::Float(((val.Int(0) << 24) & SIMD::Int(0xFF000000))) * SIMD::Float(1.0f / float(0x7f000000)), SIMD::Float(-1.0f)), SIMD::Float(1.0f)));
 			dst.move(1, Min(Max(SIMD::Float(((val.Int(0) << 16) & SIMD::Int(0xFF000000))) * SIMD::Float(1.0f / float(0x7f000000)), SIMD::Float(-1.0f)), SIMD::Float(1.0f)));
 			dst.move(2, Min(Max(SIMD::Float(((val.Int(0) << 8) & SIMD::Int(0xFF000000))) * SIMD::Float(1.0f / float(0x7f000000)), SIMD::Float(-1.0f)), SIMD::Float(1.0f)));
@@ -443,7 +443,7 @@
 		break;
 	case GLSLstd450UnpackUnorm4x8:
 		{
-			auto val = Operand(this, state, insn.word(5));
+			auto val = Operand(shader, *this, insn.word(5));
 			dst.move(0, SIMD::Float((val.UInt(0) & SIMD::UInt(0xFF))) * SIMD::Float(1.0f / 255.f));
 			dst.move(1, SIMD::Float(((val.UInt(0) >> 8) & SIMD::UInt(0xFF))) * SIMD::Float(1.0f / 255.f));
 			dst.move(2, SIMD::Float(((val.UInt(0) >> 16) & SIMD::UInt(0xFF))) * SIMD::Float(1.0f / 255.f));
@@ -452,7 +452,7 @@
 		break;
 	case GLSLstd450UnpackSnorm2x16:
 		{
-			auto val = Operand(this, state, insn.word(5));
+			auto val = Operand(shader, *this, insn.word(5));
 			// clamp(f / 32767.0, -1.0, 1.0)
 			dst.move(0, Min(Max(SIMD::Float(As<SIMD::Int>((val.UInt(0) & SIMD::UInt(0x0000FFFF)) << 16)) *
 			                        SIMD::Float(1.0f / float(0x7FFF0000)),
@@ -465,7 +465,7 @@
 		break;
 	case GLSLstd450UnpackUnorm2x16:
 		{
-			auto val = Operand(this, state, insn.word(5));
+			auto val = Operand(shader, *this, insn.word(5));
 			// f / 65535.0
 			dst.move(0, SIMD::Float((val.UInt(0) & SIMD::UInt(0x0000FFFF)) << 16) * SIMD::Float(1.0f / float(0xFFFF0000)));
 			dst.move(1, SIMD::Float(val.UInt(0) & SIMD::UInt(0xFFFF0000)) * SIMD::Float(1.0f / float(0xFFFF0000)));
@@ -473,16 +473,16 @@
 		break;
 	case GLSLstd450UnpackHalf2x16:
 		{
-			auto val = Operand(this, state, insn.word(5));
+			auto val = Operand(shader, *this, insn.word(5));
 			dst.move(0, halfToFloatBits(val.UInt(0) & SIMD::UInt(0x0000FFFF)));
 			dst.move(1, halfToFloatBits((val.UInt(0) & SIMD::UInt(0xFFFF0000)) >> 16));
 		}
 		break;
 	case GLSLstd450Fma:
 		{
-			auto a = Operand(this, state, insn.word(5));
-			auto b = Operand(this, state, insn.word(6));
-			auto c = Operand(this, state, insn.word(7));
+			auto a = Operand(shader, *this, insn.word(5));
+			auto b = Operand(shader, *this, insn.word(6));
+			auto c = Operand(shader, *this, insn.word(7));
 			for(auto i = 0u; i < type.componentCount; i++)
 			{
 				dst.move(i, MulAdd(a.Float(i), b.Float(i), c.Float(i)));
@@ -491,7 +491,7 @@
 		break;
 	case GLSLstd450Frexp:
 		{
-			auto val = Operand(this, state, insn.word(5));
+			auto val = Operand(shader, *this, insn.word(5));
 			auto ptrId = Object::ID(insn.word(6));
 
 			Intermediate exp(type.componentCount);
@@ -503,12 +503,12 @@
 				exp.move(i, significandAndExponent.second);
 			}
 
-			Store(ptrId, exp, false, std::memory_order_relaxed, state);
+			Store(ptrId, exp, false, std::memory_order_relaxed);
 		}
 		break;
 	case GLSLstd450FrexpStruct:
 		{
-			auto val = Operand(this, state, insn.word(5));
+			auto val = Operand(shader, *this, insn.word(5));
 
 			for(auto i = 0u; i < val.componentCount; i++)
 			{
@@ -520,8 +520,8 @@
 		break;
 	case GLSLstd450Ldexp:
 		{
-			auto x = Operand(this, state, insn.word(5));
-			auto exp = Operand(this, state, insn.word(6));
+			auto x = Operand(shader, *this, insn.word(5));
+			auto exp = Operand(shader, *this, insn.word(6));
 
 			for(auto i = 0u; i < type.componentCount; i++)
 			{
@@ -531,7 +531,7 @@
 		break;
 	case GLSLstd450Radians:
 		{
-			auto degrees = Operand(this, state, insn.word(5));
+			auto degrees = Operand(shader, *this, insn.word(5));
 			for(auto i = 0u; i < type.componentCount; i++)
 			{
 				dst.move(i, degrees.Float(i) * SIMD::Float(PI / 180.0f));
@@ -540,7 +540,7 @@
 		break;
 	case GLSLstd450Degrees:
 		{
-			auto radians = Operand(this, state, insn.word(5));
+			auto radians = Operand(shader, *this, insn.word(5));
 			for(auto i = 0u; i < type.componentCount; i++)
 			{
 				dst.move(i, radians.Float(i) * SIMD::Float(180.0f / PI));
@@ -549,8 +549,8 @@
 		break;
 	case GLSLstd450Sin:
 		{
-			auto radians = Operand(this, state, insn.word(5));
-			Decorations d = GetDecorationsForId(insn.resultId());
+			auto radians = Operand(shader, *this, insn.word(5));
+			Decorations d = shader.GetDecorationsForId(insn.resultId());
 
 			for(auto i = 0u; i < type.componentCount; i++)
 			{
@@ -560,8 +560,8 @@
 		break;
 	case GLSLstd450Cos:
 		{
-			auto radians = Operand(this, state, insn.word(5));
-			Decorations d = GetDecorationsForId(insn.resultId());
+			auto radians = Operand(shader, *this, insn.word(5));
+			Decorations d = shader.GetDecorationsForId(insn.resultId());
 
 			for(auto i = 0u; i < type.componentCount; i++)
 			{
@@ -571,8 +571,8 @@
 		break;
 	case GLSLstd450Tan:
 		{
-			auto radians = Operand(this, state, insn.word(5));
-			Decorations d = GetDecorationsForId(insn.resultId());
+			auto radians = Operand(shader, *this, insn.word(5));
+			Decorations d = shader.GetDecorationsForId(insn.resultId());
 
 			for(auto i = 0u; i < type.componentCount; i++)
 			{
@@ -582,8 +582,8 @@
 		break;
 	case GLSLstd450Asin:
 		{
-			auto val = Operand(this, state, insn.word(5));
-			Decorations d = GetDecorationsForId(insn.resultId());
+			auto val = Operand(shader, *this, insn.word(5));
+			Decorations d = shader.GetDecorationsForId(insn.resultId());
 
 			for(auto i = 0u; i < type.componentCount; i++)
 			{
@@ -593,8 +593,8 @@
 		break;
 	case GLSLstd450Acos:
 		{
-			auto val = Operand(this, state, insn.word(5));
-			Decorations d = GetDecorationsForId(insn.resultId());
+			auto val = Operand(shader, *this, insn.word(5));
+			Decorations d = shader.GetDecorationsForId(insn.resultId());
 
 			for(auto i = 0u; i < type.componentCount; i++)
 			{
@@ -604,8 +604,8 @@
 		break;
 	case GLSLstd450Atan:
 		{
-			auto val = Operand(this, state, insn.word(5));
-			Decorations d = GetDecorationsForId(insn.resultId());
+			auto val = Operand(shader, *this, insn.word(5));
+			Decorations d = shader.GetDecorationsForId(insn.resultId());
 
 			for(auto i = 0u; i < type.componentCount; i++)
 			{
@@ -615,8 +615,8 @@
 		break;
 	case GLSLstd450Sinh:
 		{
-			auto val = Operand(this, state, insn.word(5));
-			Decorations d = GetDecorationsForId(insn.resultId());
+			auto val = Operand(shader, *this, insn.word(5));
+			Decorations d = shader.GetDecorationsForId(insn.resultId());
 
 			for(auto i = 0u; i < type.componentCount; i++)
 			{
@@ -626,8 +626,8 @@
 		break;
 	case GLSLstd450Cosh:
 		{
-			auto val = Operand(this, state, insn.word(5));
-			Decorations d = GetDecorationsForId(insn.resultId());
+			auto val = Operand(shader, *this, insn.word(5));
+			Decorations d = shader.GetDecorationsForId(insn.resultId());
 
 			for(auto i = 0u; i < type.componentCount; i++)
 			{
@@ -637,8 +637,8 @@
 		break;
 	case GLSLstd450Tanh:
 		{
-			auto val = Operand(this, state, insn.word(5));
-			Decorations d = GetDecorationsForId(insn.resultId());
+			auto val = Operand(shader, *this, insn.word(5));
+			Decorations d = shader.GetDecorationsForId(insn.resultId());
 
 			for(auto i = 0u; i < type.componentCount; i++)
 			{
@@ -648,8 +648,8 @@
 		break;
 	case GLSLstd450Asinh:
 		{
-			auto val = Operand(this, state, insn.word(5));
-			Decorations d = GetDecorationsForId(insn.resultId());
+			auto val = Operand(shader, *this, insn.word(5));
+			Decorations d = shader.GetDecorationsForId(insn.resultId());
 
 			for(auto i = 0u; i < type.componentCount; i++)
 			{
@@ -659,8 +659,8 @@
 		break;
 	case GLSLstd450Acosh:
 		{
-			auto val = Operand(this, state, insn.word(5));
-			Decorations d = GetDecorationsForId(insn.resultId());
+			auto val = Operand(shader, *this, insn.word(5));
+			Decorations d = shader.GetDecorationsForId(insn.resultId());
 
 			for(auto i = 0u; i < type.componentCount; i++)
 			{
@@ -670,8 +670,8 @@
 		break;
 	case GLSLstd450Atanh:
 		{
-			auto val = Operand(this, state, insn.word(5));
-			Decorations d = GetDecorationsForId(insn.resultId());
+			auto val = Operand(shader, *this, insn.word(5));
+			Decorations d = shader.GetDecorationsForId(insn.resultId());
 
 			for(auto i = 0u; i < type.componentCount; i++)
 			{
@@ -681,9 +681,9 @@
 		break;
 	case GLSLstd450Atan2:
 		{
-			auto x = Operand(this, state, insn.word(5));
-			auto y = Operand(this, state, insn.word(6));
-			Decorations d = GetDecorationsForId(insn.resultId());
+			auto x = Operand(shader, *this, insn.word(5));
+			auto y = Operand(shader, *this, insn.word(6));
+			Decorations d = shader.GetDecorationsForId(insn.resultId());
 
 			for(auto i = 0u; i < type.componentCount; i++)
 			{
@@ -693,9 +693,9 @@
 		break;
 	case GLSLstd450Pow:
 		{
-			auto x = Operand(this, state, insn.word(5));
-			auto y = Operand(this, state, insn.word(6));
-			Decorations d = GetDecorationsForId(insn.resultId());
+			auto x = Operand(shader, *this, insn.word(5));
+			auto y = Operand(shader, *this, insn.word(6));
+			Decorations d = shader.GetDecorationsForId(insn.resultId());
 
 			for(auto i = 0u; i < type.componentCount; i++)
 			{
@@ -705,8 +705,8 @@
 		break;
 	case GLSLstd450Exp:
 		{
-			auto val = Operand(this, state, insn.word(5));
-			Decorations d = GetDecorationsForId(insn.resultId());
+			auto val = Operand(shader, *this, insn.word(5));
+			Decorations d = shader.GetDecorationsForId(insn.resultId());
 
 			for(auto i = 0u; i < type.componentCount; i++)
 			{
@@ -716,8 +716,8 @@
 		break;
 	case GLSLstd450Log:
 		{
-			auto val = Operand(this, state, insn.word(5));
-			Decorations d = GetDecorationsForId(insn.resultId());
+			auto val = Operand(shader, *this, insn.word(5));
+			Decorations d = shader.GetDecorationsForId(insn.resultId());
 
 			for(auto i = 0u; i < type.componentCount; i++)
 			{
@@ -727,8 +727,8 @@
 		break;
 	case GLSLstd450Exp2:
 		{
-			auto val = Operand(this, state, insn.word(5));
-			Decorations d = GetDecorationsForId(insn.resultId());
+			auto val = Operand(shader, *this, insn.word(5));
+			Decorations d = shader.GetDecorationsForId(insn.resultId());
 
 			for(auto i = 0u; i < type.componentCount; i++)
 			{
@@ -738,8 +738,8 @@
 		break;
 	case GLSLstd450Log2:
 		{
-			auto val = Operand(this, state, insn.word(5));
-			Decorations d = GetDecorationsForId(insn.resultId());
+			auto val = Operand(shader, *this, insn.word(5));
+			Decorations d = shader.GetDecorationsForId(insn.resultId());
 
 			for(auto i = 0u; i < type.componentCount; i++)
 			{
@@ -749,8 +749,8 @@
 		break;
 	case GLSLstd450Sqrt:
 		{
-			auto val = Operand(this, state, insn.word(5));
-			Decorations d = GetDecorationsForId(insn.resultId());
+			auto val = Operand(shader, *this, insn.word(5));
+			Decorations d = shader.GetDecorationsForId(insn.resultId());
 
 			for(auto i = 0u; i < type.componentCount; i++)
 			{
@@ -760,8 +760,8 @@
 		break;
 	case GLSLstd450InverseSqrt:
 		{
-			auto val = Operand(this, state, insn.word(5));
-			Decorations d = GetDecorationsForId(insn.resultId());
+			auto val = Operand(shader, *this, insn.word(5));
+			Decorations d = shader.GetDecorationsForId(insn.resultId());
 
 			for(auto i = 0u; i < type.componentCount; i++)
 			{
@@ -771,7 +771,7 @@
 		break;
 	case GLSLstd450Determinant:
 		{
-			auto mat = Operand(this, state, insn.word(5));
+			auto mat = Operand(shader, *this, insn.word(5));
 
 			switch(mat.componentCount)
 			{
@@ -800,7 +800,7 @@
 		break;
 	case GLSLstd450MatrixInverse:
 		{
-			auto mat = Operand(this, state, insn.word(5));
+			auto mat = Operand(shader, *this, insn.word(5));
 
 			switch(mat.componentCount)
 			{
@@ -862,7 +862,7 @@
 		break;
 	case GLSLstd450FindILsb:
 		{
-			auto val = Operand(this, state, insn.word(5));
+			auto val = Operand(shader, *this, insn.word(5));
 			for(auto i = 0u; i < type.componentCount; i++)
 			{
 				auto v = val.UInt(i);
@@ -872,7 +872,7 @@
 		break;
 	case GLSLstd450FindSMsb:
 		{
-			auto val = Operand(this, state, insn.word(5));
+			auto val = Operand(shader, *this, insn.word(5));
 			for(auto i = 0u; i < type.componentCount; i++)
 			{
 				auto v = val.UInt(i) ^ As<SIMD::UInt>(CmpLT(val.Int(i), SIMD::Int(0)));
@@ -882,7 +882,7 @@
 		break;
 	case GLSLstd450FindUMsb:
 		{
-			auto val = Operand(this, state, insn.word(5));
+			auto val = Operand(shader, *this, insn.word(5));
 			for(auto i = 0u; i < type.componentCount; i++)
 			{
 				dst.move(i, SIMD::UInt(31) - Ctlz(val.UInt(i), false));
@@ -891,38 +891,38 @@
 		break;
 	case GLSLstd450InterpolateAtCentroid:
 		{
-			Decorations d = GetDecorationsForId(insn.word(5));
-			auto ptr = state->getPointer(insn.word(5));
+			Decorations d = shader.GetDecorationsForId(insn.word(5));
+			auto ptr = getPointer(insn.word(5));
 			for(auto i = 0u; i < type.componentCount; i++)
 			{
-				dst.move(i, EmitInterpolate(ptr, d.Location, 0, i, state, SpirvShader::Centroid));
+				dst.move(i, EmitInterpolate(ptr, d.Location, 0, i, Centroid));
 			}
 		}
 		break;
 	case GLSLstd450InterpolateAtSample:
 		{
-			Decorations d = GetDecorationsForId(insn.word(5));
-			auto ptr = state->getPointer(insn.word(5));
+			Decorations d = shader.GetDecorationsForId(insn.word(5));
+			auto ptr = getPointer(insn.word(5));
 			for(auto i = 0u; i < type.componentCount; i++)
 			{
-				dst.move(i, EmitInterpolate(ptr, d.Location, insn.word(6), i, state, SpirvShader::AtSample));
+				dst.move(i, EmitInterpolate(ptr, d.Location, insn.word(6), i, AtSample));
 			}
 		}
 		break;
 	case GLSLstd450InterpolateAtOffset:
 		{
-			Decorations d = GetDecorationsForId(insn.word(5));
-			auto ptr = state->getPointer(insn.word(5));
+			Decorations d = shader.GetDecorationsForId(insn.word(5));
+			auto ptr = getPointer(insn.word(5));
 			for(auto i = 0u; i < type.componentCount; i++)
 			{
-				dst.move(i, EmitInterpolate(ptr, d.Location, insn.word(6), i, state, SpirvShader::AtOffset));
+				dst.move(i, EmitInterpolate(ptr, d.Location, insn.word(6), i, AtOffset));
 			}
 		}
 		break;
 	case GLSLstd450NMin:
 		{
-			auto x = Operand(this, state, insn.word(5));
-			auto y = Operand(this, state, insn.word(6));
+			auto x = Operand(shader, *this, insn.word(5));
+			auto y = Operand(shader, *this, insn.word(6));
 			for(auto i = 0u; i < type.componentCount; i++)
 			{
 				dst.move(i, NMin(x.Float(i), y.Float(i)));
@@ -931,8 +931,8 @@
 		break;
 	case GLSLstd450NMax:
 		{
-			auto x = Operand(this, state, insn.word(5));
-			auto y = Operand(this, state, insn.word(6));
+			auto x = Operand(shader, *this, insn.word(5));
+			auto y = Operand(shader, *this, insn.word(6));
 			for(auto i = 0u; i < type.componentCount; i++)
 			{
 				dst.move(i, NMax(x.Float(i), y.Float(i)));
@@ -941,9 +941,9 @@
 		break;
 	case GLSLstd450NClamp:
 		{
-			auto x = Operand(this, state, insn.word(5));
-			auto minVal = Operand(this, state, insn.word(6));
-			auto maxVal = Operand(this, state, insn.word(7));
+			auto x = Operand(shader, *this, insn.word(5));
+			auto minVal = Operand(shader, *this, insn.word(6));
+			auto maxVal = Operand(shader, *this, insn.word(7));
 			for(auto i = 0u; i < type.componentCount; i++)
 			{
 				auto clamp = NMin(NMax(x.Float(i), minVal.Float(i)), maxVal.Float(i));
@@ -978,23 +978,23 @@
 	return interpolant;
 }
 
-SIMD::Float SpirvShader::EmitInterpolate(const SIMD::Pointer &ptr, int32_t location, Object::ID paramId,
-                                         uint32_t component, EmitState *state, InterpolationType type) const
+SIMD::Float SpirvShader::EmitState::EmitInterpolate(const SIMD::Pointer &ptr, int32_t location, Object::ID paramId,
+                                                    uint32_t component, InterpolationType type) const
 {
 	uint32_t interpolant = (location * 4);
-	uint32_t components_per_row = GetNumInputComponents(location);
-	if((location < 0) || (interpolant >= inputs.size()) || (components_per_row == 0))
+	uint32_t components_per_row = shader.GetNumInputComponents(location);
+	if((location < 0) || (interpolant >= shader.inputs.size()) || (components_per_row == 0))
 	{
 		return SIMD::Float(0.0f);
 	}
 
-	const auto &interpolationData = state->routine->interpolationData;
+	const auto &interpolationData = routine->interpolationData;
 
 	SIMD::Float x;
 	SIMD::Float y;
 	SIMD::Float rhw;
 
-	bool multisample = (state->getMultiSampleCount() > 1);
+	bool multisample = (getMultiSampleCount() > 1);
 	switch(type)
 	{
 	case Centroid:
@@ -1018,9 +1018,9 @@
 		if(multisample)
 		{
 			static constexpr int NUM_SAMPLES = 4;
-			ASSERT(state->getMultiSampleCount() == NUM_SAMPLES);
+			ASSERT(getMultiSampleCount() == NUM_SAMPLES);
 
-			auto sampleOperand = Operand(this, state, paramId);
+			auto sampleOperand = Operand(shader, *this, paramId);
 			ASSERT(sampleOperand.componentCount == 1);
 
 			// If sample does not exist, the position used to interpolate the
@@ -1030,8 +1030,8 @@
 			for(int i = 0; i < SIMD::Width; i++)
 			{
 				Int sample = Extract(samples, i);
-				x = Insert(x, *Pointer<Float>(state->routine->constants + OFFSET(Constants, SampleLocationsX) + sample * sizeof(float)), i);
-				y = Insert(y, *Pointer<Float>(state->routine->constants + OFFSET(Constants, SampleLocationsY) + sample * sizeof(float)), i);
+				x = Insert(x, *Pointer<Float>(routine->constants + OFFSET(Constants, SampleLocationsX) + sample * sizeof(float)), i);
+				y = Insert(y, *Pointer<Float>(routine->constants + OFFSET(Constants, SampleLocationsY) + sample * sizeof(float)), i);
 			}
 		}
 
@@ -1042,7 +1042,7 @@
 	case AtOffset:
 		{
 			//  An offset of (0, 0) identifies the center of the pixel.
-			auto offset = Operand(this, state, paramId);
+			auto offset = Operand(shader, *this, paramId);
 			ASSERT(offset.componentCount == 2);
 
 			x = interpolationData.x + offset.Float(0);
@@ -1055,7 +1055,7 @@
 		return SIMD::Float(0.0f);
 	}
 
-	uint32_t packedInterpolant = GetPackedInterpolant(location);
+	uint32_t packedInterpolant = shader.GetPackedInterpolant(location);
 	Pointer<Byte> planeEquation = interpolationData.primitive + OFFSET(Primitive, V[packedInterpolant]);
 
 	// The pointer's offsets index into the input variable array, which are SIMD::Float vectors.
@@ -1078,21 +1078,21 @@
 			C = Insert(C, *Pointer<Float>(planeEquationI + OFFSET(PlaneEquation, C)), i);
 		}
 
-		return Interpolate(x, y, rhw, A, B, C, state->routine->inputsInterpolation[packedInterpolant]);
+		return Interpolate(x, y, rhw, A, B, C, routine->inputsInterpolation[packedInterpolant]);
 	}
 	else
 	{
 		ASSERT(ptr.hasStaticEqualOffsets());
 
 		uint32_t offset = (ptr.staticOffsets[0] >> offsetShift) + component;
-		if((interpolant + offset) >= inputs.size())
+		if((interpolant + offset) >= shader.inputs.size())
 		{
 			return SIMD::Float(0.0f);
 		}
 		planeEquation += offset * sizeof(PlaneEquation);
 	}
 
-	return SpirvRoutine::interpolateAtXY(x, y, rhw, planeEquation, state->routine->inputsInterpolation[packedInterpolant]);
+	return SpirvRoutine::interpolateAtXY(x, y, rhw, planeEquation, routine->inputsInterpolation[packedInterpolant]);
 }
 
 SIMD::Float SpirvRoutine::interpolateAtXY(const SIMD::Float &x, const SIMD::Float &y, const SIMD::Float &rhw, Pointer<Byte> planeEquation, Interpolation interpolation)
diff --git a/src/Pipeline/SpirvShaderGroup.cpp b/src/Pipeline/SpirvShaderGroup.cpp
index a081437..86687c8 100644
--- a/src/Pipeline/SpirvShaderGroup.cpp
+++ b/src/Pipeline/SpirvShaderGroup.cpp
@@ -64,16 +64,16 @@
 	}
 }
 
-SpirvShader::EmitResult SpirvShader::EmitGroupNonUniform(InsnIterator insn, EmitState *state) const
+SpirvShader::EmitResult SpirvShader::EmitState::EmitGroupNonUniform(InsnIterator insn)
 {
 	ASSERT(SIMD::Width == 4);  // EmitGroupNonUniform makes many assumptions that the SIMD vector width is 4
 
-	auto &type = getType(Type::ID(insn.word(1)));
+	auto &type = shader.getType(Type::ID(insn.word(1)));
 	Object::ID resultId = insn.word(2);
-	auto scope = spv::Scope(GetConstScalarInt(insn.word(3)));
+	auto scope = spv::Scope(shader.GetConstScalarInt(insn.word(3)));
 	ASSERT_MSG(scope == spv::ScopeSubgroup, "Scope for Non Uniform Group Operations must be Subgroup for Vulkan 1.1");
 
-	auto &dst = state->createIntermediate(resultId, type.componentCount);
+	auto &dst = createIntermediate(resultId, type.componentCount);
 
 	switch(insn.opcode())
 	{
@@ -81,7 +81,7 @@
 		{
 			// Result is true only in the active invocation with the lowest id
 			// in the group, otherwise result is false.
-			SIMD::Int active = state->activeLaneMask();  // Considers helper invocations active. See b/151137030
+			SIMD::Int active = activeLaneMask();  // Considers helper invocations active. See b/151137030
 			// TODO: Would be nice if we could write this as:
 			//   elect = active & ~(active.Oxyz | active.OOxy | active.OOOx)
 			auto v0111 = SIMD::Int(0, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF);
@@ -92,23 +92,23 @@
 
 	case spv::OpGroupNonUniformAll:
 		{
-			Operand predicate(this, state, insn.word(4));
-			dst.move(0, AndAll(predicate.UInt(0) | ~As<SIMD::UInt>(state->activeLaneMask())));  // Considers helper invocations active. See b/151137030
+			Operand predicate(shader, *this, insn.word(4));
+			dst.move(0, AndAll(predicate.UInt(0) | ~As<SIMD::UInt>(activeLaneMask())));  // Considers helper invocations active. See b/151137030
 		}
 		break;
 
 	case spv::OpGroupNonUniformAny:
 		{
-			Operand predicate(this, state, insn.word(4));
-			dst.move(0, OrAll(predicate.UInt(0) & As<SIMD::UInt>(state->activeLaneMask())));  // Considers helper invocations active. See b/151137030
+			Operand predicate(shader, *this, insn.word(4));
+			dst.move(0, OrAll(predicate.UInt(0) & As<SIMD::UInt>(activeLaneMask())));  // Considers helper invocations active. See b/151137030
 		}
 		break;
 
 	case spv::OpGroupNonUniformAllEqual:
 		{
-			Operand value(this, state, insn.word(4));
+			Operand value(shader, *this, insn.word(4));
 			auto res = SIMD::UInt(0xffffffff);
-			SIMD::UInt active = As<SIMD::UInt>(state->activeLaneMask());  // Considers helper invocations active. See b/151137030
+			SIMD::UInt active = As<SIMD::UInt>(activeLaneMask());  // Considers helper invocations active. See b/151137030
 			SIMD::UInt inactive = ~active;
 			for(auto i = 0u; i < type.componentCount; i++)
 			{
@@ -128,13 +128,13 @@
 		{
 			auto valueId = Object::ID(insn.word(4));
 			auto idId = Object::ID(insn.word(5));
-			Operand value(this, state, valueId);
+			Operand value(shader, *this, valueId);
 
 			// Decide between the fast path for constants and the slow path for
 			// intermediates.
-			if(getObject(idId).kind == SpirvShader::Object::Kind::Constant)
+			if(shader.getObject(idId).kind == SpirvShader::Object::Kind::Constant)
 			{
-				auto id = SIMD::Int(GetConstScalarInt(insn.word(5)));
+				auto id = SIMD::Int(shader.GetConstScalarInt(insn.word(5)));
 				auto mask = CmpEQ(id, SIMD::Int(0, 1, 2, 3));
 				for(auto i = 0u; i < type.componentCount; i++)
 				{
@@ -143,9 +143,9 @@
 			}
 			else
 			{
-				Operand id(this, state, idId);
+				Operand id(shader, *this, idId);
 
-				SIMD::UInt active = As<SIMD::UInt>(state->activeLaneMask());  // Considers helper invocations active. See b/151137030
+				SIMD::UInt active = As<SIMD::UInt>(activeLaneMask());  // Considers helper invocations active. See b/151137030
 				SIMD::UInt inactive = ~active;
 				SIMD::UInt filled = id.UInt(0) & active;
 
@@ -167,10 +167,10 @@
 	case spv::OpGroupNonUniformBroadcastFirst:
 		{
 			auto valueId = Object::ID(insn.word(4));
-			Operand value(this, state, valueId);
+			Operand value(shader, *this, valueId);
 			// Result is true only in the active invocation with the lowest id
 			// in the group, otherwise result is false.
-			SIMD::Int active = state->activeLaneMask();  // Considers helper invocations active. See b/151137030
+			SIMD::Int active = activeLaneMask();  // Considers helper invocations active. See b/151137030
 			// TODO: Would be nice if we could write this as:
 			//   elect = active & ~(active.Oxyz | active.OOxy | active.OOOx)
 			auto v0111 = SIMD::Int(0, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF);
@@ -185,13 +185,13 @@
 	case spv::OpGroupNonUniformQuadBroadcast:
 		{
 			auto valueId = Object::ID(insn.word(4));
-			Operand value(this, state, valueId);
+			Operand value(shader, *this, valueId);
 
-			ASSERT(getType(getObject(insn.word(5))).componentCount == 1);
+			ASSERT(shader.getType(shader.getObject(insn.word(5))).componentCount == 1);
 			auto indexId = Object::ID(insn.word(5));
-			SIMD::Int index = Operand(this, state, indexId).Int(0);
+			SIMD::Int index = Operand(shader, *this, indexId).Int(0);
 
-			SIMD::Int active = state->activeLaneMask();
+			SIMD::Int active = activeLaneMask();
 			// Populate all lanes in index with the same value. Index is required to be
 			// uniform per the SPIR-V spec, so all active lanes should be identical.
 			index = OrAll(active & index);
@@ -208,9 +208,9 @@
 		{
 			auto valueId = Object::ID(insn.word(4));
 			// SPIR-V spec: Drection must be a scalar of integer type and come from a constant instruction
-			int direction = GetConstScalarInt(insn.word(5));
+			int direction = shader.GetConstScalarInt(insn.word(5));
 
-			Operand value(this, state, valueId);
+			Operand value(shader, *this, valueId);
 			for(auto i = 0u; i < type.componentCount; i++)
 			{
 				SIMD::Int v = value.Int(i);
@@ -238,8 +238,8 @@
 	case spv::OpGroupNonUniformBallot:
 		{
 			ASSERT(type.componentCount == 4);
-			Operand predicate(this, state, insn.word(4));
-			dst.move(0, SIMD::Int(SignMask(state->activeLaneMask() & predicate.Int(0))));  // Considers helper invocations active. See b/151137030
+			Operand predicate(shader, *this, insn.word(4));
+			dst.move(0, SIMD::Int(SignMask(activeLaneMask() & predicate.Int(0))));  // Considers helper invocations active. See b/151137030
 			dst.move(1, SIMD::Int(0));
 			dst.move(2, SIMD::Int(0));
 			dst.move(3, SIMD::Int(0));
@@ -250,8 +250,8 @@
 		{
 			auto valueId = Object::ID(insn.word(4));
 			ASSERT(type.componentCount == 1);
-			ASSERT(getObjectType(valueId).componentCount == 4);
-			Operand value(this, state, valueId);
+			ASSERT(shader.getObjectType(valueId).componentCount == 4);
+			Operand value(shader, *this, valueId);
 			auto bit = (value.Int(0) >> SIMD::Int(0, 1, 2, 3)) & SIMD::Int(1);
 			dst.move(0, -bit);
 		}
@@ -262,10 +262,10 @@
 			auto valueId = Object::ID(insn.word(4));
 			auto indexId = Object::ID(insn.word(5));
 			ASSERT(type.componentCount == 1);
-			ASSERT(getObjectType(valueId).componentCount == 4);
-			ASSERT(getObjectType(indexId).componentCount == 1);
-			Operand value(this, state, valueId);
-			Operand index(this, state, indexId);
+			ASSERT(shader.getObjectType(valueId).componentCount == 4);
+			ASSERT(shader.getObjectType(indexId).componentCount == 1);
+			Operand value(shader, *this, valueId);
+			Operand index(shader, *this, indexId);
 			auto vecIdx = index.Int(0) / SIMD::Int(32);
 			auto bitIdx = index.Int(0) & SIMD::Int(31);
 			auto bits = (value.Int(0) & CmpEQ(vecIdx, SIMD::Int(0))) |
@@ -281,8 +281,8 @@
 			auto operation = spv::GroupOperation(insn.word(4));
 			auto valueId = Object::ID(insn.word(5));
 			ASSERT(type.componentCount == 1);
-			ASSERT(getObjectType(valueId).componentCount == 4);
-			Operand value(this, state, valueId);
+			ASSERT(shader.getObjectType(valueId).componentCount == 4);
+			Operand value(shader, *this, valueId);
 			switch(operation)
 			{
 			case spv::GroupOperationReduce:
@@ -304,8 +304,8 @@
 		{
 			auto valueId = Object::ID(insn.word(4));
 			ASSERT(type.componentCount == 1);
-			ASSERT(getObjectType(valueId).componentCount == 4);
-			Operand value(this, state, valueId);
+			ASSERT(shader.getObjectType(valueId).componentCount == 4);
+			Operand value(shader, *this, valueId);
 			dst.move(0, Cttz(value.UInt(0) & SIMD::UInt(15), true));
 		}
 		break;
@@ -314,16 +314,16 @@
 		{
 			auto valueId = Object::ID(insn.word(4));
 			ASSERT(type.componentCount == 1);
-			ASSERT(getObjectType(valueId).componentCount == 4);
-			Operand value(this, state, valueId);
+			ASSERT(shader.getObjectType(valueId).componentCount == 4);
+			Operand value(shader, *this, valueId);
 			dst.move(0, SIMD::UInt(31) - Ctlz(value.UInt(0) & SIMD::UInt(15), false));
 		}
 		break;
 
 	case spv::OpGroupNonUniformShuffle:
 		{
-			Operand value(this, state, insn.word(4));
-			Operand id(this, state, insn.word(5));
+			Operand value(shader, *this, insn.word(4));
+			Operand id(shader, *this, insn.word(5));
 			auto x = CmpEQ(SIMD::Int(0), id.Int(0));
 			auto y = CmpEQ(SIMD::Int(1), id.Int(0));
 			auto z = CmpEQ(SIMD::Int(2), id.Int(0));
@@ -338,8 +338,8 @@
 
 	case spv::OpGroupNonUniformShuffleXor:
 		{
-			Operand value(this, state, insn.word(4));
-			Operand mask(this, state, insn.word(5));
+			Operand value(shader, *this, insn.word(4));
+			Operand mask(shader, *this, insn.word(5));
 			auto x = CmpEQ(SIMD::Int(0), SIMD::Int(0, 1, 2, 3) ^ mask.Int(0));
 			auto y = CmpEQ(SIMD::Int(1), SIMD::Int(0, 1, 2, 3) ^ mask.Int(0));
 			auto z = CmpEQ(SIMD::Int(2), SIMD::Int(0, 1, 2, 3) ^ mask.Int(0));
@@ -354,8 +354,8 @@
 
 	case spv::OpGroupNonUniformShuffleUp:
 		{
-			Operand value(this, state, insn.word(4));
-			Operand delta(this, state, insn.word(5));
+			Operand value(shader, *this, insn.word(4));
+			Operand delta(shader, *this, insn.word(5));
 			auto d0 = CmpEQ(SIMD::Int(0), delta.Int(0));
 			auto d1 = CmpEQ(SIMD::Int(1), delta.Int(0));
 			auto d2 = CmpEQ(SIMD::Int(2), delta.Int(0));
@@ -370,8 +370,8 @@
 
 	case spv::OpGroupNonUniformShuffleDown:
 		{
-			Operand value(this, state, insn.word(4));
-			Operand delta(this, state, insn.word(5));
+			Operand value(shader, *this, insn.word(4));
+			Operand delta(shader, *this, insn.word(5));
 			auto d0 = CmpEQ(SIMD::Int(0), delta.Int(0));
 			auto d1 = CmpEQ(SIMD::Int(1), delta.Int(0));
 			auto d2 = CmpEQ(SIMD::Int(2), delta.Int(0));
@@ -386,10 +386,10 @@
 
 	// The remaining instructions are GroupNonUniformArithmetic operations
 	default:
-		auto &type = getType(SpirvShader::Type::ID(insn.word(1)));
+		auto &type = shader.getType(SpirvShader::Type::ID(insn.word(1)));
 		auto operation = static_cast<spv::GroupOperation>(insn.word(4));
-		SpirvShader::Operand value(this, state, insn.word(5));
-		auto mask = As<SIMD::UInt>(state->activeLaneMask());  // Considers helper invocations active. See b/151137030
+		SpirvShader::Operand value(shader, *this, insn.word(5));
+		auto mask = As<SIMD::UInt>(activeLaneMask());  // Considers helper invocations active. See b/151137030
 
 		for(uint32_t i = 0; i < type.componentCount; i++)
 		{
diff --git a/src/Pipeline/SpirvShaderImage.cpp b/src/Pipeline/SpirvShaderImage.cpp
index 04e5873..ec9662f 100644
--- a/src/Pipeline/SpirvShaderImage.cpp
+++ b/src/Pipeline/SpirvShaderImage.cpp
@@ -74,7 +74,7 @@
 	}
 }
 
-SpirvShader::ImageInstruction::ImageInstruction(InsnIterator insn, const SpirvShader &spirv, EmitState *state)
+SpirvShader::ImageInstruction::ImageInstruction(InsnIterator insn, const SpirvShader &spirv, const EmitState &state)
     : ImageInstructionSignature(parseVariantAndMethod(insn))
     , position(insn.distanceFrom(spirv.begin()))
 {
@@ -99,9 +99,9 @@
 			// an externally combined sampler and image.
 			Object::ID sampledImageId = insn.word(3);
 
-			if(state->isSampledImage(sampledImageId))  // Result of an OpSampledImage instruction
+			if(state.isSampledImage(sampledImageId))  // Result of an OpSampledImage instruction
 			{
-				const SampledImagePointer &sampledImage = state->getSampledImage(sampledImageId);
+				const SampledImagePointer &sampledImage = state.getSampledImage(sampledImageId);
 				imageId = spirv.getObject(sampledImageId).definition.word(3);
 				samplerId = sampledImage.samplerId;
 			}
@@ -329,18 +329,18 @@
 	return (operandsIndex != 0) ? insn.word(operandsIndex) : 0;
 }
 
-SpirvShader::EmitResult SpirvShader::EmitImageSample(const ImageInstruction &instruction, EmitState *state) const
+SpirvShader::EmitResult SpirvShader::EmitState::EmitImageSample(const ImageInstruction &instruction)
 {
-	auto &resultType = getType(instruction.resultTypeId);
-	auto &result = state->createIntermediate(instruction.resultId, resultType.componentCount);
+	auto &resultType = shader.getType(instruction.resultTypeId);
+	auto &result = createIntermediate(instruction.resultId, resultType.componentCount);
 	Array<SIMD::Float> out(4);
 
 	// TODO(b/153380916): When we're in a code path that is always executed,
 	// i.e. post-dominators of the entry block, we don't have to dynamically
 	// check whether any lanes are active, and can elide the jump.
-	If(AnyTrue(state->activeLaneMask()))
+	If(AnyTrue(activeLaneMask()))
 	{
-		EmitImageSampleUnconditional(out, instruction, state);
+		EmitImageSampleUnconditional(out, instruction);
 	}
 
 	for(auto i = 0u; i < resultType.componentCount; i++) { result.move(i, out[i]); }
@@ -348,14 +348,14 @@
 	return EmitResult::Continue;
 }
 
-void SpirvShader::EmitImageSampleUnconditional(Array<SIMD::Float> &out, const ImageInstruction &instruction, EmitState *state) const
+void SpirvShader::EmitState::EmitImageSampleUnconditional(Array<SIMD::Float> &out, const ImageInstruction &instruction) const
 {
-	auto decorations = GetDecorationsForId(instruction.imageId);
+	auto decorations = shader.GetDecorationsForId(instruction.imageId);
 
 	if(decorations.NonUniform)
 	{
-		SIMD::Int activeLaneMask = state->activeLaneMask();
-		SIMD::Pointer imagePointer = state->getImage(instruction.imageId);
+		SIMD::Int activeLaneMask = this->activeLaneMask();
+		SIMD::Pointer imagePointer = getImage(instruction.imageId);
 		// PerLane output
 		for(int laneIdx = 0; laneIdx < SIMD::Width; laneIdx++)
 		{
@@ -363,11 +363,11 @@
 			If(Extract(activeLaneMask, laneIdx) != 0)
 			{
 				Pointer<Byte> imageDescriptor = imagePointer.getPointerForLane(laneIdx);  // vk::SampledImageDescriptor*
-				Pointer<Byte> samplerDescriptor = getSamplerDescriptor(imageDescriptor, instruction, laneIdx, state);
+				Pointer<Byte> samplerDescriptor = getSamplerDescriptor(imageDescriptor, instruction, laneIdx);
 
-				Pointer<Byte> samplerFunction = lookupSamplerFunction(imageDescriptor, samplerDescriptor, instruction, state);
+				Pointer<Byte> samplerFunction = lookupSamplerFunction(imageDescriptor, samplerDescriptor, instruction);
 
-				callSamplerFunction(samplerFunction, laneOut, imageDescriptor, instruction, state);
+				callSamplerFunction(samplerFunction, laneOut, imageDescriptor, instruction);
 			}
 
 			for(int outIdx = 0; outIdx < out.getArraySize(); outIdx++)
@@ -378,36 +378,36 @@
 	}
 	else
 	{
-		Pointer<Byte> imageDescriptor = state->getImage(instruction.imageId).getUniformPointer();  // vk::SampledImageDescriptor*
-		Pointer<Byte> samplerDescriptor = getSamplerDescriptor(imageDescriptor, instruction, state);
+		Pointer<Byte> imageDescriptor = getImage(instruction.imageId).getUniformPointer();  // vk::SampledImageDescriptor*
+		Pointer<Byte> samplerDescriptor = getSamplerDescriptor(imageDescriptor, instruction);
 
-		Pointer<Byte> samplerFunction = lookupSamplerFunction(imageDescriptor, samplerDescriptor, instruction, state);
+		Pointer<Byte> samplerFunction = lookupSamplerFunction(imageDescriptor, samplerDescriptor, instruction);
 
-		callSamplerFunction(samplerFunction, out, imageDescriptor, instruction, state);
+		callSamplerFunction(samplerFunction, out, imageDescriptor, instruction);
 	}
 }
 
-Pointer<Byte> SpirvShader::getSamplerDescriptor(Pointer<Byte> imageDescriptor, const ImageInstruction &instruction, EmitState *state) const
+Pointer<Byte> SpirvShader::EmitState::getSamplerDescriptor(Pointer<Byte> imageDescriptor, const ImageInstruction &instruction) const
 {
-	return ((instruction.samplerId == instruction.imageId) || (instruction.samplerId == 0)) ? imageDescriptor : state->getImage(instruction.samplerId).getUniformPointer();
+	return ((instruction.samplerId == instruction.imageId) || (instruction.samplerId == 0)) ? imageDescriptor : getImage(instruction.samplerId).getUniformPointer();
 }
 
-Pointer<Byte> SpirvShader::getSamplerDescriptor(Pointer<Byte> imageDescriptor, const ImageInstruction &instruction, int laneIdx, EmitState *state) const
+Pointer<Byte> SpirvShader::EmitState::getSamplerDescriptor(Pointer<Byte> imageDescriptor, const ImageInstruction &instruction, int laneIdx) const
 {
-	return ((instruction.samplerId == instruction.imageId) || (instruction.samplerId == 0)) ? imageDescriptor : state->getImage(instruction.samplerId).getPointerForLane(laneIdx);
+	return ((instruction.samplerId == instruction.imageId) || (instruction.samplerId == 0)) ? imageDescriptor : getImage(instruction.samplerId).getPointerForLane(laneIdx);
 }
 
-Pointer<Byte> SpirvShader::lookupSamplerFunction(Pointer<Byte> imageDescriptor, Pointer<Byte> samplerDescriptor, const ImageInstruction &instruction, EmitState *state) const
+Pointer<Byte> SpirvShader::EmitState::lookupSamplerFunction(Pointer<Byte> imageDescriptor, Pointer<Byte> samplerDescriptor, const ImageInstruction &instruction) const
 {
 	Int samplerId = (instruction.samplerId != 0) ? *Pointer<rr::Int>(samplerDescriptor + OFFSET(vk::SampledImageDescriptor, samplerId)) : Int(0);
 
-	auto &cache = state->routine->samplerCache.at(instruction.position);
+	auto &cache = routine->samplerCache.at(instruction.position);
 	Bool cacheHit = (cache.imageDescriptor == imageDescriptor) && (cache.samplerId == samplerId);  // TODO(b/205566405): Skip sampler ID check for samplerless instructions.
 
 	If(!cacheHit)
 	{
 		rr::Int imageViewId = *Pointer<rr::Int>(imageDescriptor + OFFSET(vk::ImageDescriptor, imageViewId));
-		cache.function = Call(getImageSampler, state->routine->device, instruction.signature, samplerId, imageViewId);
+		cache.function = Call(getImageSampler, routine->device, instruction.signature, samplerId, imageViewId);
 		cache.imageDescriptor = imageDescriptor;
 		cache.samplerId = samplerId;
 	}
@@ -415,11 +415,11 @@
 	return cache.function;
 }
 
-void SpirvShader::callSamplerFunction(Pointer<Byte> samplerFunction, Array<SIMD::Float> &out, Pointer<Byte> imageDescriptor, const ImageInstruction &instruction, EmitState *state) const
+void SpirvShader::EmitState::callSamplerFunction(Pointer<Byte> samplerFunction, Array<SIMD::Float> &out, Pointer<Byte> imageDescriptor, const ImageInstruction &instruction) const
 {
 	Array<SIMD::Float> in(16);  // Maximum 16 input parameter components.
 
-	auto coordinate = Operand(this, state, instruction.coordinateId);
+	auto coordinate = Operand(shader, *this, instruction.coordinateId);
 
 	uint32_t i = 0;
 	for(; i < instruction.coordinates; i++)
@@ -436,7 +436,7 @@
 
 	if(instruction.isDref())
 	{
-		auto drefValue = Operand(this, state, instruction.drefId);
+		auto drefValue = Operand(shader, *this, instruction.drefId);
 
 		if(instruction.isProj())
 		{
@@ -452,14 +452,14 @@
 
 	if(instruction.lodOrBiasId != 0)
 	{
-		auto lodValue = Operand(this, state, instruction.lodOrBiasId);
+		auto lodValue = Operand(shader, *this, instruction.lodOrBiasId);
 		in[i] = lodValue.Float(0);
 		i++;
 	}
 	else if(instruction.gradDxId != 0)
 	{
-		auto dxValue = Operand(this, state, instruction.gradDxId);
-		auto dyValue = Operand(this, state, instruction.gradDyId);
+		auto dxValue = Operand(shader, *this, instruction.gradDxId);
+		auto dyValue = Operand(shader, *this, instruction.gradDyId);
 		ASSERT(dxValue.componentCount == dxValue.componentCount);
 
 		for(uint32_t j = 0; j < dxValue.componentCount; j++, i++)
@@ -483,7 +483,7 @@
 
 	if(instruction.offsetId != 0)
 	{
-		auto offsetValue = Operand(this, state, instruction.offsetId);
+		auto offsetValue = Operand(shader, *this, instruction.offsetId);
 
 		for(uint32_t j = 0; j < offsetValue.componentCount; j++, i++)
 		{
@@ -493,53 +493,52 @@
 
 	if(instruction.sample)
 	{
-		auto sampleValue = Operand(this, state, instruction.sampleId);
+		auto sampleValue = Operand(shader, *this, instruction.sampleId);
 		in[i] = As<SIMD::Float>(sampleValue.Int(0));
 	}
 
 	Pointer<Byte> texture = imageDescriptor + OFFSET(vk::SampledImageDescriptor, texture);  // sw::Texture*
 
-	Call<ImageSampler>(samplerFunction, texture, &in, &out, state->routine->constants);
+	Call<ImageSampler>(samplerFunction, texture, &in, &out, routine->constants);
 }
 
-SpirvShader::EmitResult SpirvShader::EmitImageQuerySizeLod(InsnIterator insn, EmitState *state) const
+SpirvShader::EmitResult SpirvShader::EmitState::EmitImageQuerySizeLod(InsnIterator insn)
 {
-	auto &resultTy = getType(insn.resultTypeId());
+	auto &resultTy = shader.getType(insn.resultTypeId());
 	auto imageId = Object::ID(insn.word(3));
 	auto lodId = Object::ID(insn.word(4));
 
-	auto &dst = state->createIntermediate(insn.resultId(), resultTy.componentCount);
-	GetImageDimensions(state, resultTy, imageId, lodId, dst);
+	auto &dst = createIntermediate(insn.resultId(), resultTy.componentCount);
+	GetImageDimensions(resultTy, imageId, lodId, dst);
 
 	return EmitResult::Continue;
 }
 
-SpirvShader::EmitResult SpirvShader::EmitImageQuerySize(InsnIterator insn, EmitState *state) const
+SpirvShader::EmitResult SpirvShader::EmitState::EmitImageQuerySize(InsnIterator insn)
 {
-	auto &resultTy = getType(insn.resultTypeId());
+	auto &resultTy = shader.getType(insn.resultTypeId());
 	auto imageId = Object::ID(insn.word(3));
 	auto lodId = Object::ID(0);
 
-	auto &dst = state->createIntermediate(insn.resultId(), resultTy.componentCount);
-	GetImageDimensions(state, resultTy, imageId, lodId, dst);
+	auto &dst = createIntermediate(insn.resultId(), resultTy.componentCount);
+	GetImageDimensions(resultTy, imageId, lodId, dst);
 
 	return EmitResult::Continue;
 }
 
-void SpirvShader::GetImageDimensions(const EmitState *state, const Type &resultTy, Object::ID imageId, Object::ID lodId, Intermediate &dst) const
+void SpirvShader::EmitState::GetImageDimensions(const Type &resultTy, Object::ID imageId, Object::ID lodId, Intermediate &dst) const
 {
-	auto routine = state->routine;
-	auto &image = getObject(imageId);
-	auto &imageType = getType(image);
+	auto &image = shader.getObject(imageId);
+	auto &imageType = shader.getType(image);
 
 	ASSERT(imageType.definition.opcode() == spv::OpTypeImage);
 	bool isArrayed = imageType.definition.word(5) != 0;
 	uint32_t dimensions = resultTy.componentCount - (isArrayed ? 1 : 0);
 
-	const DescriptorDecorations &d = descriptorDecorations.at(imageId);
+	const DescriptorDecorations &d = shader.descriptorDecorations.at(imageId);
 	auto descriptorType = routine->pipelineLayout->getDescriptorType(d.DescriptorSet, d.Binding);
 
-	Pointer<Byte> descriptor = state->getPointer(imageId).getUniformPointer();
+	Pointer<Byte> descriptor = getPointer(imageId).getUniformPointer();
 
 	Int width;
 	Int height;
@@ -566,7 +565,7 @@
 
 	if(lodId != 0)
 	{
-		auto lodVal = Operand(this, state, lodId);
+		auto lodVal = Operand(shader, *this, lodId);
 		ASSERT(lodVal.componentCount == 1);
 		auto lod = lodVal.Int(0);
 		auto one = SIMD::Int(1);
@@ -589,16 +588,16 @@
 	}
 }
 
-SpirvShader::EmitResult SpirvShader::EmitImageQueryLevels(InsnIterator insn, EmitState *state) const
+SpirvShader::EmitResult SpirvShader::EmitState::EmitImageQueryLevels(InsnIterator insn)
 {
-	auto &resultTy = getType(insn.resultTypeId());
+	auto &resultTy = shader.getType(insn.resultTypeId());
 	ASSERT(resultTy.componentCount == 1);
 	auto imageId = Object::ID(insn.word(3));
 
-	const DescriptorDecorations &d = descriptorDecorations.at(imageId);
-	auto descriptorType = state->routine->pipelineLayout->getDescriptorType(d.DescriptorSet, d.Binding);
+	const DescriptorDecorations &d = shader.descriptorDecorations.at(imageId);
+	auto descriptorType = routine->pipelineLayout->getDescriptorType(d.DescriptorSet, d.Binding);
 
-	Pointer<Byte> descriptor = state->getPointer(imageId).getUniformPointer();
+	Pointer<Byte> descriptor = getPointer(imageId).getUniformPointer();
 	Int mipLevels = 0;
 	switch(descriptorType)
 	{
@@ -611,26 +610,26 @@
 		UNREACHABLE("Image descriptorType: %d", int(descriptorType));
 	}
 
-	auto &dst = state->createIntermediate(insn.resultId(), 1);
+	auto &dst = createIntermediate(insn.resultId(), 1);
 	dst.move(0, SIMD::Int(mipLevels));
 
 	return EmitResult::Continue;
 }
 
-SpirvShader::EmitResult SpirvShader::EmitImageQuerySamples(InsnIterator insn, EmitState *state) const
+SpirvShader::EmitResult SpirvShader::EmitState::EmitImageQuerySamples(InsnIterator insn)
 {
-	auto &resultTy = getType(insn.resultTypeId());
+	auto &resultTy = shader.getType(insn.resultTypeId());
 	ASSERT(resultTy.componentCount == 1);
 	auto imageId = Object::ID(insn.word(3));
-	auto imageTy = getObjectType(imageId);
+	auto imageTy = shader.getObjectType(imageId);
 	ASSERT(imageTy.definition.opcode() == spv::OpTypeImage);
 	ASSERT(imageTy.definition.word(3) == spv::Dim2D);
 	ASSERT(imageTy.definition.word(6 /* MS */) == 1);
 
-	const DescriptorDecorations &d = descriptorDecorations.at(imageId);
-	auto descriptorType = state->routine->pipelineLayout->getDescriptorType(d.DescriptorSet, d.Binding);
+	const DescriptorDecorations &d = shader.descriptorDecorations.at(imageId);
+	auto descriptorType = routine->pipelineLayout->getDescriptorType(d.DescriptorSet, d.Binding);
 
-	Pointer<Byte> descriptor = state->getPointer(imageId).getUniformPointer();
+	Pointer<Byte> descriptor = getPointer(imageId).getUniformPointer();
 	Int sampleCount = 0;
 	switch(descriptorType)
 	{
@@ -646,13 +645,13 @@
 		UNREACHABLE("Image descriptorType: %d", int(descriptorType));
 	}
 
-	auto &dst = state->createIntermediate(insn.resultId(), 1);
+	auto &dst = createIntermediate(insn.resultId(), 1);
 	dst.move(0, SIMD::Int(sampleCount));
 
 	return EmitResult::Continue;
 }
 
-SpirvShader::TexelAddressData SpirvShader::setupTexelAddressData(SIMD::Int rowPitch, SIMD::Int slicePitch, SIMD::Int samplePitch, ImageInstructionSignature instruction, SIMD::Int coordinate[], SIMD::Int sample, vk::Format imageFormat, const EmitState *state)
+SpirvShader::EmitState::TexelAddressData SpirvShader::EmitState::setupTexelAddressData(SIMD::Int rowPitch, SIMD::Int slicePitch, SIMD::Int samplePitch, ImageInstructionSignature instruction, SIMD::Int coordinate[], SIMD::Int sample, vk::Format imageFormat, const SpirvRoutine *routine)
 {
 	TexelAddressData data;
 
@@ -671,8 +670,8 @@
 
 	if(data.dim == spv::DimSubpassData)
 	{
-		data.u += state->routine->windowSpacePosition[0];
-		data.v += state->routine->windowSpacePosition[1];
+		data.u += routine->windowSpacePosition[0];
+		data.v += routine->windowSpacePosition[1];
 	}
 
 	data.ptrOffset = data.u * SIMD::Int(data.texelSize);
@@ -701,7 +700,7 @@
 	if(data.dim == spv::DimSubpassData)
 	{
 		// Multiview input attachment access is to the layer corresponding to the current view
-		data.ptrOffset += SIMD::Int(state->routine->layer) * slicePitch;
+		data.ptrOffset += SIMD::Int(routine->layer) * slicePitch;
 	}
 
 	if(instruction.sample)
@@ -712,48 +711,47 @@
 	return data;
 }
 
-SIMD::Pointer SpirvShader::GetNonUniformTexelAddress(ImageInstructionSignature instruction, SIMD::Pointer descriptor, SIMD::Int coordinate[], SIMD::Int sample, vk::Format imageFormat, OutOfBoundsBehavior outOfBoundsBehavior, const EmitState *state)
+SIMD::Pointer SpirvShader::EmitState::GetNonUniformTexelAddress(ImageInstructionSignature instruction, SIMD::Pointer descriptor, SIMD::Int coordinate[], SIMD::Int sample, vk::Format imageFormat, OutOfBoundsBehavior outOfBoundsBehavior, SIMD::Int activeLaneMask, const SpirvRoutine *routine)
 {
 	const bool useStencilAspect = (imageFormat == VK_FORMAT_S8_UINT);
 	auto rowPitch = (descriptor + (useStencilAspect
 	                                   ? OFFSET(vk::StorageImageDescriptor, stencilRowPitchBytes)
 	                                   : OFFSET(vk::StorageImageDescriptor, rowPitchBytes)))
-	                    .Load<SIMD::Int>(outOfBoundsBehavior, state->activeLaneMask());
-
+	                    .Load<SIMD::Int>(outOfBoundsBehavior, activeLaneMask);
 	auto slicePitch = (descriptor + (useStencilAspect
 	                                     ? OFFSET(vk::StorageImageDescriptor, stencilSlicePitchBytes)
 	                                     : OFFSET(vk::StorageImageDescriptor, slicePitchBytes)))
-	                      .Load<SIMD::Int>(outOfBoundsBehavior, state->activeLaneMask());
+	                      .Load<SIMD::Int>(outOfBoundsBehavior, activeLaneMask);
 	auto samplePitch = (descriptor + (useStencilAspect
 	                                      ? OFFSET(vk::StorageImageDescriptor, stencilSamplePitchBytes)
 	                                      : OFFSET(vk::StorageImageDescriptor, samplePitchBytes)))
-	                       .Load<SIMD::Int>(outOfBoundsBehavior, state->activeLaneMask());
+	                       .Load<SIMD::Int>(outOfBoundsBehavior, activeLaneMask);
 
-	auto texelData = setupTexelAddressData(rowPitch, slicePitch, samplePitch, instruction, coordinate, sample, imageFormat, state);
+	auto texelData = setupTexelAddressData(rowPitch, slicePitch, samplePitch, instruction, coordinate, sample, imageFormat, routine);
 
 	// If the out-of-bounds behavior is set to nullify, then each coordinate must be tested individually.
 	// Other out-of-bounds behaviors work properly by just comparing the offset against the total size.
 	if(outOfBoundsBehavior == OutOfBoundsBehavior::Nullify)
 	{
-		SIMD::UInt width = (descriptor + OFFSET(vk::StorageImageDescriptor, width)).Load<SIMD::Int>(outOfBoundsBehavior, state->activeLaneMask());
+		SIMD::UInt width = (descriptor + OFFSET(vk::StorageImageDescriptor, width)).Load<SIMD::Int>(outOfBoundsBehavior, activeLaneMask);
 		SIMD::Int oobMask = As<SIMD::Int>(CmpNLT(As<SIMD::UInt>(texelData.u), width));
 
 		if(texelData.dims > 1)
 		{
-			SIMD::UInt height = As<SIMD::UInt>((descriptor + OFFSET(vk::StorageImageDescriptor, height)).Load<SIMD::Int>(outOfBoundsBehavior, state->activeLaneMask()));
+			SIMD::UInt height = As<SIMD::UInt>((descriptor + OFFSET(vk::StorageImageDescriptor, height)).Load<SIMD::Int>(outOfBoundsBehavior, activeLaneMask));
 			oobMask |= As<SIMD::Int>(CmpNLT(As<SIMD::UInt>(texelData.v), height));
 		}
 
 		if((texelData.dims > 2) || texelData.isArrayed)
 		{
-			SIMD::UInt depth = As<SIMD::UInt>((descriptor + OFFSET(vk::StorageImageDescriptor, depth)).Load<SIMD::Int>(outOfBoundsBehavior, state->activeLaneMask()));
+			SIMD::UInt depth = As<SIMD::UInt>((descriptor + OFFSET(vk::StorageImageDescriptor, depth)).Load<SIMD::Int>(outOfBoundsBehavior, activeLaneMask));
 			if(texelData.dim == spv::DimCube) { depth *= 6; }
 			oobMask |= As<SIMD::Int>(CmpNLT(As<SIMD::UInt>(texelData.w), depth));
 		}
 
 		if(instruction.sample)
 		{
-			SIMD::UInt sampleCount = As<SIMD::UInt>((descriptor + OFFSET(vk::StorageImageDescriptor, sampleCount)).Load<SIMD::Int>(outOfBoundsBehavior, state->activeLaneMask()));
+			SIMD::UInt sampleCount = As<SIMD::UInt>((descriptor + OFFSET(vk::StorageImageDescriptor, sampleCount)).Load<SIMD::Int>(outOfBoundsBehavior, activeLaneMask));
 			oobMask |= As<SIMD::Int>(CmpNLT(As<SIMD::UInt>(sample), sampleCount));
 		}
 
@@ -774,7 +772,7 @@
 	return SIMD::Pointer(imageBase) + texelData.ptrOffset;
 }
 
-SIMD::Pointer SpirvShader::GetTexelAddress(ImageInstructionSignature instruction, Pointer<Byte> descriptor, SIMD::Int coordinate[], SIMD::Int sample, vk::Format imageFormat, OutOfBoundsBehavior outOfBoundsBehavior, const EmitState *state)
+SIMD::Pointer SpirvShader::EmitState::GetTexelAddress(ImageInstructionSignature instruction, Pointer<Byte> descriptor, SIMD::Int coordinate[], SIMD::Int sample, vk::Format imageFormat, OutOfBoundsBehavior outOfBoundsBehavior, const SpirvRoutine *routine)
 {
 	const bool useStencilAspect = (imageFormat == VK_FORMAT_S8_UINT);
 	auto rowPitch = SIMD::Int(*Pointer<Int>(descriptor + (useStencilAspect
@@ -789,7 +787,7 @@
 	                                    ? OFFSET(vk::StorageImageDescriptor, stencilSamplePitchBytes)
 	                                    : OFFSET(vk::StorageImageDescriptor, samplePitchBytes))));
 
-	auto texelData = setupTexelAddressData(rowPitch, slicePitch, samplePitch, instruction, coordinate, sample, imageFormat, state);
+	auto texelData = setupTexelAddressData(rowPitch, slicePitch, samplePitch, instruction, coordinate, sample, imageFormat, routine);
 
 	// If the out-of-bounds behavior is set to nullify, then each coordinate must be tested individually.
 	// Other out-of-bounds behaviors work properly by just comparing the offset against the total size.
@@ -832,36 +830,36 @@
 	return SIMD::Pointer(imageBase, imageSizeInBytes, texelData.ptrOffset);
 }
 
-SpirvShader::EmitResult SpirvShader::EmitImageRead(const ImageInstruction &instruction, EmitState *state) const
+SpirvShader::EmitResult SpirvShader::EmitState::EmitImageRead(const ImageInstruction &instruction)
 {
-	auto &resultType = getObjectType(instruction.resultId);
-	auto &image = getObject(instruction.imageId);
-	auto &imageType = getType(image);
+	auto &resultType = shader.getObjectType(instruction.resultId);
+	auto &image = shader.getObject(instruction.imageId);
+	auto &imageType = shader.getType(image);
 
 	ASSERT(imageType.definition.opcode() == spv::OpTypeImage);
 	auto dim = static_cast<spv::Dim>(instruction.dim);
 
-	auto coordinate = Operand(this, state, instruction.coordinateId);
-	const DescriptorDecorations &d = descriptorDecorations.at(instruction.imageId);
+	auto coordinate = Operand(shader, *this, instruction.coordinateId);
+	const DescriptorDecorations &d = shader.descriptorDecorations.at(instruction.imageId);
 
 	// For subpass data, format in the instruction is spv::ImageFormatUnknown. Get it from
 	// the renderpass data instead. In all other cases, we can use the format in the instruction.
 	vk::Format imageFormat = (dim == spv::DimSubpassData)
-	                             ? inputAttachmentFormats[d.InputAttachmentIndex]
+	                             ? shader.inputAttachmentFormats[d.InputAttachmentIndex]
 	                             : SpirvFormatToVulkanFormat(static_cast<spv::ImageFormat>(instruction.imageFormat));
 
 	// Depth+Stencil image attachments select aspect based on the Sampled Type of the
 	// OpTypeImage. If float, then we want the depth aspect. If int, we want the stencil aspect.
 	bool useStencilAspect = (imageFormat == VK_FORMAT_D32_SFLOAT_S8_UINT &&
-	                         getType(imageType.definition.word(2)).opcode() == spv::OpTypeInt);
+	                         shader.getType(imageType.definition.word(2)).opcode() == spv::OpTypeInt);
 
 	if(useStencilAspect)
 	{
 		imageFormat = VK_FORMAT_S8_UINT;
 	}
 
-	auto &dst = state->createIntermediate(instruction.resultId, resultType.componentCount);
-	SIMD::Pointer ptr = state->getPointer(instruction.imageId);
+	auto &dst = createIntermediate(instruction.resultId, resultType.componentCount);
+	SIMD::Pointer ptr = getPointer(instruction.imageId);
 
 	SIMD::Int uvwa[4];
 	SIMD::Int sample;
@@ -876,7 +874,7 @@
 	}
 	if(instruction.sample)
 	{
-		sample = Operand(this, state, instruction.sampleId).Int(0);
+		sample = Operand(shader, *this, instruction.sampleId).Int(0);
 	}
 
 	// Gather packed texel data. Texels larger than 4 bytes occupy multiple SIMD::Int elements.
@@ -884,19 +882,19 @@
 	SIMD::Int packed[4];
 
 	SIMD::Pointer texelPtr = ptr.isBasePlusOffset
-	                             ? GetTexelAddress(instruction, ptr.getUniformPointer(), uvwa, sample, imageFormat, robustness, state)
-	                             : GetNonUniformTexelAddress(instruction, ptr, uvwa, sample, imageFormat, robustness, state);
+	                             ? GetTexelAddress(instruction, ptr.getUniformPointer(), uvwa, sample, imageFormat, robustness, routine)
+	                             : GetNonUniformTexelAddress(instruction, ptr, uvwa, sample, imageFormat, robustness, activeLaneMask(), routine);
 	if(texelSize == 4 || texelSize == 8 || texelSize == 16)
 	{
 		for(auto i = 0; i < texelSize / 4; i++)
 		{
-			packed[i] = texelPtr.Load<SIMD::Int>(robustness, state->activeLaneMask());
+			packed[i] = texelPtr.Load<SIMD::Int>(robustness, activeLaneMask());
 			texelPtr += sizeof(float);
 		}
 	}
 	else if(texelSize == 2)
 	{
-		SIMD::Int mask = state->activeLaneMask() & texelPtr.isInBounds(2, robustness);
+		SIMD::Int mask = activeLaneMask() & texelPtr.isInBounds(2, robustness);
 
 		for(int i = 0; i < SIMD::Width; i++)
 		{
@@ -908,7 +906,7 @@
 	}
 	else if(texelSize == 1)
 	{
-		SIMD::Int mask = state->activeLaneMask() & texelPtr.isInBounds(1, robustness);
+		SIMD::Int mask = activeLaneMask() & texelPtr.isInBounds(1, robustness);
 		for(int i = 0; i < SIMD::Width; i++)
 		{
 			If(Extract(mask, i) != 0)
@@ -1247,16 +1245,16 @@
 	return EmitResult::Continue;
 }
 
-SpirvShader::EmitResult SpirvShader::EmitImageWrite(const ImageInstruction &instruction, EmitState *state) const
+SpirvShader::EmitResult SpirvShader::EmitState::EmitImageWrite(const ImageInstruction &instruction) const
 {
-	auto &image = getObject(instruction.imageId);
-	auto &imageType = getType(image);
+	auto &image = shader.getObject(instruction.imageId);
+	auto &imageType = shader.getType(image);
 
 	ASSERT(imageType.definition.opcode() == spv::OpTypeImage);
 	ASSERT(static_cast<spv::Dim>(instruction.dim) != spv::DimSubpassData);  // "Its Dim operand must not be SubpassData."
 
-	auto coordinate = Operand(this, state, instruction.coordinateId);
-	auto texel = Operand(this, state, instruction.texelId);
+	auto coordinate = Operand(shader, *this, instruction.coordinateId);
+	auto texel = Operand(shader, *this, instruction.texelId);
 
 	Array<SIMD::Int> coord(5);  // uvwa & sample
 
@@ -1268,7 +1266,7 @@
 
 	if(instruction.sample)
 	{
-		coord[i] = Operand(this, state, instruction.sampleId).Int(0);
+		coord[i] = Operand(shader, *this, instruction.sampleId).Int(0);
 	}
 
 	Array<SIMD::Int> texelAndMask(5);
@@ -1276,21 +1274,21 @@
 	texelAndMask[1] = texel.Int(1);
 	texelAndMask[2] = texel.Int(2);
 	texelAndMask[3] = texel.Int(3);
-	texelAndMask[4] = state->activeStoresAndAtomicsMask();
+	texelAndMask[4] = activeStoresAndAtomicsMask();
 
 	vk::Format imageFormat = SpirvFormatToVulkanFormat(static_cast<spv::ImageFormat>(instruction.imageFormat));
 
-	SIMD::Pointer ptr = state->getPointer(instruction.imageId);
+	SIMD::Pointer ptr = getPointer(instruction.imageId);
 	if(ptr.isBasePlusOffset)
 	{
 		Pointer<Byte> imageDescriptor = ptr.getUniformPointer();  // vk::StorageImageDescriptor* or vk::SampledImageDescriptor*
-		Pointer<Byte> samplerDescriptor = getSamplerDescriptor(imageDescriptor, instruction, state);
+		Pointer<Byte> samplerDescriptor = getSamplerDescriptor(imageDescriptor, instruction);
 
 		if(imageFormat == VK_FORMAT_UNDEFINED)  // spv::ImageFormatUnknown
 		{
-			Pointer<Byte> samplerFunction = lookupSamplerFunction(imageDescriptor, samplerDescriptor, instruction, state);
+			Pointer<Byte> samplerFunction = lookupSamplerFunction(imageDescriptor, samplerDescriptor, instruction);
 
-			Call<ImageSampler>(samplerFunction, imageDescriptor, &coord, &texelAndMask, state->routine->constants);
+			Call<ImageSampler>(samplerFunction, imageDescriptor, &coord, &texelAndMask, routine->constants);
 		}
 		else
 		{
@@ -1303,14 +1301,15 @@
 		{
 			SIMD::Int singleLaneMask = 0;
 			singleLaneMask = Insert(singleLaneMask, 0xffffffff, j);
-			texelAndMask[4] = state->activeStoresAndAtomicsMask() & singleLaneMask;
+			texelAndMask[4] = activeStoresAndAtomicsMask() & singleLaneMask;
 			Pointer<Byte> imageDescriptor = ptr.getPointerForLane(j);
-			Pointer<Byte> samplerDescriptor = getSamplerDescriptor(imageDescriptor, instruction, j, state);
+			Pointer<Byte> samplerDescriptor = getSamplerDescriptor(imageDescriptor, instruction, j);
+
 			if(imageFormat == VK_FORMAT_UNDEFINED)  // spv::ImageFormatUnknown
 			{
-				Pointer<Byte> samplerFunction = lookupSamplerFunction(imageDescriptor, samplerDescriptor, instruction, state);
+				Pointer<Byte> samplerFunction = lookupSamplerFunction(imageDescriptor, samplerDescriptor, instruction);
 
-				Call<ImageSampler>(samplerFunction, imageDescriptor, &coord, &texelAndMask, state->routine->constants);
+				Call<ImageSampler>(samplerFunction, imageDescriptor, &coord, &texelAndMask, routine->constants);
 			}
 			else
 			{
@@ -1322,7 +1321,7 @@
 	return EmitResult::Continue;
 }
 
-void SpirvShader::WriteImage(ImageInstructionSignature instruction, Pointer<Byte> descriptor, const Pointer<SIMD::Int> &coord, const Pointer<SIMD::Int> &texelAndMask, vk::Format imageFormat)
+void SpirvShader::EmitState::WriteImage(ImageInstructionSignature instruction, Pointer<Byte> descriptor, const Pointer<SIMD::Int> &coord, const Pointer<SIMD::Int> &texelAndMask, vk::Format imageFormat)
 {
 	SIMD::Int texel[4];
 	texel[0] = texelAndMask[0];
@@ -1493,8 +1492,8 @@
 	//  validation. If the texel fails integer texel coordinate validation, then the write has no effect."
 	// - https://www.khronos.org/registry/vulkan/specs/1.2/html/chap16.html#textures-output-coordinate-validation
 	auto robustness = OutOfBoundsBehavior::Nullify;
-	// GetTexelAddress() only needs the EmitState* for SubpassData accesses (i.e. input attachments).
-	const EmitState *state = nullptr;
+	// GetTexelAddress() only needs the SpirvRoutine* for SubpassData accesses (i.e. input attachments).
+	const SpirvRoutine *routine = nullptr;
 
 	SIMD::Int uvwa[4];
 	SIMD::Int sample;
@@ -1510,7 +1509,7 @@
 		sample = As<SIMD::Int>(coord[i]);
 	}
 
-	auto texelPtr = GetTexelAddress(instruction, descriptor, uvwa, sample, imageFormat, robustness, state);
+	auto texelPtr = GetTexelAddress(instruction, descriptor, uvwa, sample, imageFormat, robustness, routine);
 
 	const int texelSize = imageFormat.bytes();
 
@@ -1552,11 +1551,11 @@
 		UNREACHABLE("texelSize: %d", int(texelSize));
 }
 
-SpirvShader::EmitResult SpirvShader::EmitImageTexelPointer(const ImageInstruction &instruction, EmitState *state) const
+SpirvShader::EmitResult SpirvShader::EmitState::EmitImageTexelPointer(const ImageInstruction &instruction)
 {
-	auto coordinate = Operand(this, state, instruction.coordinateId);
+	auto coordinate = Operand(shader, *this, instruction.coordinateId);
 
-	SIMD::Pointer ptr = state->getPointer(instruction.imageId);
+	SIMD::Pointer ptr = getPointer(instruction.imageId);
 
 	// VK_EXT_image_robustness requires checking for out-of-bounds accesses.
 	// TODO(b/162327166): Only perform bounds checks when VK_EXT_image_robustness is enabled.
@@ -1570,36 +1569,36 @@
 		uvwa[i] = coordinate.Int(i);
 	}
 
-	SIMD::Int sample = Operand(this, state, instruction.sampleId).Int(0);
+	SIMD::Int sample = Operand(shader, *this, instruction.sampleId).Int(0);
 
 	auto texelPtr = ptr.isBasePlusOffset
-	                    ? GetTexelAddress(instruction, ptr.getUniformPointer(), uvwa, sample, imageFormat, robustness, state)
-	                    : GetNonUniformTexelAddress(instruction, ptr, uvwa, sample, imageFormat, robustness, state);
+	                    ? GetTexelAddress(instruction, ptr.getUniformPointer(), uvwa, sample, imageFormat, robustness, routine)
+	                    : GetNonUniformTexelAddress(instruction, ptr, uvwa, sample, imageFormat, robustness, activeLaneMask(), routine);
 
-	state->createPointer(instruction.resultId, texelPtr);
+	createPointer(instruction.resultId, texelPtr);
 
 	return EmitResult::Continue;
 }
 
-SpirvShader::EmitResult SpirvShader::EmitSampledImage(InsnIterator insn, EmitState *state) const
+SpirvShader::EmitResult SpirvShader::EmitState::EmitSampledImage(InsnIterator insn)
 {
 	Object::ID resultId = insn.word(2);
 	Object::ID imageId = insn.word(3);
 	Object::ID samplerId = insn.word(4);
 
 	// Create a sampled image, containing both a sampler and an image
-	state->createSampledImage(resultId, { state->getPointer(imageId), samplerId });
+	createSampledImage(resultId, { getPointer(imageId), samplerId });
 
 	return EmitResult::Continue;
 }
 
-SpirvShader::EmitResult SpirvShader::EmitImage(InsnIterator insn, EmitState *state) const
+SpirvShader::EmitResult SpirvShader::EmitState::EmitImage(InsnIterator insn)
 {
 	Object::ID resultId = insn.word(2);
 	Object::ID imageId = insn.word(3);
 
 	// Extract the image from a sampled image.
-	state->createPointer(resultId, state->getImage(imageId));
+	createPointer(resultId, getImage(imageId));
 
 	return EmitResult::Continue;
 }
diff --git a/src/Pipeline/SpirvShaderMemory.cpp b/src/Pipeline/SpirvShaderMemory.cpp
index 90818a4..5921e6e 100644
--- a/src/Pipeline/SpirvShaderMemory.cpp
+++ b/src/Pipeline/SpirvShaderMemory.cpp
@@ -23,65 +23,65 @@
 
 namespace sw {
 
-SpirvShader::EmitResult SpirvShader::EmitLoad(InsnIterator insn, EmitState *state) const
+SpirvShader::EmitResult SpirvShader::EmitState::EmitLoad(InsnIterator insn)
 {
 	bool atomic = (insn.opcode() == spv::OpAtomicLoad);
 	Object::ID resultId = insn.word(2);
 	Object::ID pointerId = insn.word(3);
-	auto &result = getObject(resultId);
-	auto &resultTy = getType(result);
-	auto &pointer = getObject(pointerId);
-	auto &pointerTy = getType(pointer);
+	auto &result = shader.getObject(resultId);
+	auto &resultTy = shader.getType(result);
+	auto &pointer = shader.getObject(pointerId);
+	auto &pointerTy = shader.getType(pointer);
 	std::memory_order memoryOrder = std::memory_order_relaxed;
 
-	ASSERT(getType(pointer).element == result.typeId());
+	ASSERT(shader.getType(pointer).element == result.typeId());
 	ASSERT(Type::ID(insn.word(1)) == result.typeId());
-	ASSERT(!atomic || getType(getType(pointer).element).opcode() == spv::OpTypeInt);  // Vulkan 1.1: "Atomic instructions must declare a scalar 32-bit integer type, for the value pointed to by Pointer."
+	ASSERT(!atomic || shader.getType(shader.getType(pointer).element).opcode() == spv::OpTypeInt);  // Vulkan 1.1: "Atomic instructions must declare a scalar 32-bit integer type, for the value pointed to by Pointer."
 
 	if(pointerTy.storageClass == spv::StorageClassUniformConstant)
 	{
 		// Just propagate the pointer.
-		auto &ptr = state->getPointer(pointerId);
-		state->createPointer(resultId, ptr);
+		auto &ptr = getPointer(pointerId);
+		createPointer(resultId, ptr);
 		return EmitResult::Continue;
 	}
 
 	if(atomic)
 	{
 		Object::ID semanticsId = insn.word(5);
-		auto memorySemantics = static_cast<spv::MemorySemanticsMask>(getObject(semanticsId).constantValue[0]);
+		auto memorySemantics = static_cast<spv::MemorySemanticsMask>(shader.getObject(semanticsId).constantValue[0]);
 		memoryOrder = MemoryOrder(memorySemantics);
 	}
 
-	auto ptr = GetPointerToData(pointerId, 0, false, state);
+	auto ptr = GetPointerToData(pointerId, 0, false);
 	bool interleavedByLane = IsStorageInterleavedByLane(pointerTy.storageClass);
-	auto robustness = getOutOfBoundsBehavior(pointerId, state);
+	auto robustness = shader.getOutOfBoundsBehavior(pointerId, routine->pipelineLayout);
 
 	if(result.kind == Object::Kind::Pointer)
 	{
-		VisitMemoryObject(pointerId, true, [&](const MemoryElement &el) {
+		shader.VisitMemoryObject(pointerId, true, [&](const MemoryElement &el) {
 			ASSERT(el.index == 0);
 			auto p = GetElementPointer(ptr, el.offset, interleavedByLane);
-			state->createPointer(resultId, p.Load<SIMD::Pointer>(robustness, state->activeLaneMask(), atomic, memoryOrder, sizeof(void *)));
+			createPointer(resultId, p.Load<SIMD::Pointer>(robustness, activeLaneMask(), atomic, memoryOrder, sizeof(void *)));
 		});
 
-		SPIRV_SHADER_DBG("Load(atomic: {0}, order: {1}, ptr: {2}, mask: {3})", atomic, int(memoryOrder), ptr, state->activeLaneMask());
+		SPIRV_SHADER_DBG("Load(atomic: {0}, order: {1}, ptr: {2}, mask: {3})", atomic, int(memoryOrder), ptr, activeLaneMask());
 	}
 	else
 	{
-		auto &dst = state->createIntermediate(resultId, resultTy.componentCount);
-		VisitMemoryObject(pointerId, false, [&](const MemoryElement &el) {
+		auto &dst = createIntermediate(resultId, resultTy.componentCount);
+		shader.VisitMemoryObject(pointerId, false, [&](const MemoryElement &el) {
 			auto p = GetElementPointer(ptr, el.offset, interleavedByLane);
-			dst.move(el.index, p.Load<SIMD::Float>(robustness, state->activeLaneMask(), atomic, memoryOrder));
+			dst.move(el.index, p.Load<SIMD::Float>(robustness, activeLaneMask(), atomic, memoryOrder));
 		});
 
-		SPIRV_SHADER_DBG("Load(atomic: {0}, order: {1}, ptr: {2}, val: {3}, mask: {4})", atomic, int(memoryOrder), ptr, dst, state->activeLaneMask());
+		SPIRV_SHADER_DBG("Load(atomic: {0}, order: {1}, ptr: {2}, val: {3}, mask: {4})", atomic, int(memoryOrder), ptr, dst, activeLaneMask());
 	}
 
 	return EmitResult::Continue;
 }
 
-SpirvShader::EmitResult SpirvShader::EmitStore(InsnIterator insn, EmitState *state) const
+SpirvShader::EmitResult SpirvShader::EmitState::EmitStore(InsnIterator insn)
 {
 	bool atomic = (insn.opcode() == spv::OpAtomicStore);
 	Object::ID pointerId = insn.word(1);
@@ -91,40 +91,40 @@
 	if(atomic)
 	{
 		Object::ID semanticsId = insn.word(3);
-		auto memorySemantics = static_cast<spv::MemorySemanticsMask>(getObject(semanticsId).constantValue[0]);
+		auto memorySemantics = static_cast<spv::MemorySemanticsMask>(shader.getObject(semanticsId).constantValue[0]);
 		memoryOrder = MemoryOrder(memorySemantics);
 	}
 
-	const auto &value = Operand(this, state, objectId);
+	const auto &value = Operand(shader, *this, objectId);
 
-	Store(pointerId, value, atomic, memoryOrder, state);
+	Store(pointerId, value, atomic, memoryOrder);
 
 	return EmitResult::Continue;
 }
 
-void SpirvShader::Store(Object::ID pointerId, const Operand &value, bool atomic, std::memory_order memoryOrder, EmitState *state) const
+void SpirvShader::EmitState::Store(Object::ID pointerId, const Operand &value, bool atomic, std::memory_order memoryOrder) const
 {
-	auto &pointer = getObject(pointerId);
-	auto &pointerTy = getType(pointer);
-	auto &elementTy = getType(pointerTy.element);
+	auto &pointer = shader.getObject(pointerId);
+	auto &pointerTy = shader.getType(pointer);
+	auto &elementTy = shader.getType(pointerTy.element);
 
 	ASSERT(!atomic || elementTy.opcode() == spv::OpTypeInt);  // Vulkan 1.1: "Atomic instructions must declare a scalar 32-bit integer type, for the value pointed to by Pointer."
 
-	auto ptr = GetPointerToData(pointerId, 0, false, state);
+	auto ptr = GetPointerToData(pointerId, 0, false);
 	bool interleavedByLane = IsStorageInterleavedByLane(pointerTy.storageClass);
-	auto robustness = getOutOfBoundsBehavior(pointerId, state);
+	auto robustness = shader.getOutOfBoundsBehavior(pointerId, routine->pipelineLayout);
 
-	SIMD::Int mask = state->activeLaneMask();
+	SIMD::Int mask = activeLaneMask();
 	if(!StoresInHelperInvocation(pointerTy.storageClass))
 	{
-		mask = mask & state->storesAndAtomicsMask();
+		mask = mask & storesAndAtomicsMask();
 	}
 
 	SPIRV_SHADER_DBG("Store(atomic: {0}, order: {1}, ptr: {2}, val: {3}, mask: {4}", atomic, int(memoryOrder), ptr, value, mask);
 
 	if(value.isPointer())
 	{
-		VisitMemoryObject(pointerId, true, [&](const MemoryElement &el) {
+		shader.VisitMemoryObject(pointerId, true, [&](const MemoryElement &el) {
 			ASSERT(el.index == 0);
 			auto p = GetElementPointer(ptr, el.offset, interleavedByLane);
 			p.Store(value.Pointer(), robustness, mask, atomic, memoryOrder);
@@ -132,19 +132,18 @@
 	}
 	else
 	{
-		VisitMemoryObject(pointerId, false, [&](const MemoryElement &el) {
+		shader.VisitMemoryObject(pointerId, false, [&](const MemoryElement &el) {
 			auto p = GetElementPointer(ptr, el.offset, interleavedByLane);
 			p.Store(value.Float(el.index), robustness, mask, atomic, memoryOrder);
 		});
 	}
 }
 
-SpirvShader::EmitResult SpirvShader::EmitVariable(InsnIterator insn, EmitState *state) const
+SpirvShader::EmitResult SpirvShader::EmitState::EmitVariable(InsnIterator insn)
 {
-	auto routine = state->routine;
 	Object::ID resultId = insn.word(2);
-	auto &object = getObject(resultId);
-	auto &objectTy = getType(object);
+	auto &object = shader.getObject(resultId);
+	auto &objectTy = shader.getType(object);
 
 	switch(objectTy.storageClass)
 	{
@@ -154,17 +153,17 @@
 		{
 			ASSERT(objectTy.opcode() == spv::OpTypePointer);
 			auto base = &routine->getVariable(resultId)[0];
-			auto elementTy = getType(objectTy.element);
+			auto elementTy = shader.getType(objectTy.element);
 			auto size = elementTy.componentCount * static_cast<uint32_t>(sizeof(float)) * SIMD::Width;
-			state->createPointer(resultId, SIMD::Pointer(base, size));
+			createPointer(resultId, SIMD::Pointer(base, size));
 		}
 		break;
 	case spv::StorageClassWorkgroup:
 		{
 			ASSERT(objectTy.opcode() == spv::OpTypePointer);
 			auto base = &routine->workgroupMemory[0];
-			auto size = workgroupMemory.size();
-			state->createPointer(resultId, SIMD::Pointer(base, size, workgroupMemory.offsetOf(resultId)));
+			auto size = shader.workgroupMemory.size();
+			createPointer(resultId, SIMD::Pointer(base, size, shader.workgroupMemory.offsetOf(resultId)));
 		}
 		break;
 	case spv::StorageClassInput:
@@ -173,22 +172,22 @@
 			{
 				auto &dst = routine->getVariable(resultId);
 				int offset = 0;
-				VisitInterface(resultId,
-				               [&](const Decorations &d, AttribType type) {
-					               auto scalarSlot = d.Location << 2 | d.Component;
-					               dst[offset++] = routine->inputs[scalarSlot];
-				               });
+				shader.VisitInterface(resultId,
+				                      [&](const Decorations &d, AttribType type) {
+					                      auto scalarSlot = d.Location << 2 | d.Component;
+					                      dst[offset++] = routine->inputs[scalarSlot];
+				                      });
 			}
 			ASSERT(objectTy.opcode() == spv::OpTypePointer);
 			auto base = &routine->getVariable(resultId)[0];
-			auto elementTy = getType(objectTy.element);
+			auto elementTy = shader.getType(objectTy.element);
 			auto size = elementTy.componentCount * static_cast<uint32_t>(sizeof(float)) * SIMD::Width;
-			state->createPointer(resultId, SIMD::Pointer(base, size));
+			createPointer(resultId, SIMD::Pointer(base, size));
 		}
 		break;
 	case spv::StorageClassUniformConstant:
 		{
-			const auto &d = descriptorDecorations.at(resultId);
+			const auto &d = shader.descriptorDecorations.at(resultId);
 			ASSERT(d.DescriptorSet >= 0);
 			ASSERT(d.Binding >= 0);
 
@@ -196,14 +195,14 @@
 			Pointer<Byte> set = routine->descriptorSets[d.DescriptorSet];  // DescriptorSet*
 			Pointer<Byte> binding = Pointer<Byte>(set + bindingOffset);    // vk::SampledImageDescriptor*
 			auto size = 0;                                                 // Not required as this pointer is not directly used by SIMD::Read or SIMD::Write.
-			state->createPointer(resultId, SIMD::Pointer(binding, size));
+			createPointer(resultId, SIMD::Pointer(binding, size));
 		}
 		break;
 	case spv::StorageClassUniform:
 	case spv::StorageClassStorageBuffer:
 	case spv::StorageClassPhysicalStorageBuffer:
 		{
-			const auto &d = descriptorDecorations.at(resultId);
+			const auto &d = shader.descriptorDecorations.at(resultId);
 			ASSERT(d.DescriptorSet >= 0);
 			auto size = 0;  // Not required as this pointer is not directly used by SIMD::Read or SIMD::Write.
 			// Note: the module may contain descriptor set references that are not suitable for this implementation -- using a set index higher than the number
@@ -211,17 +210,17 @@
 			// is valid. In this case make the value nullptr to make it easier to diagnose an attempt to dereference it.
 			if(static_cast<uint32_t>(d.DescriptorSet) < vk::MAX_BOUND_DESCRIPTOR_SETS)
 			{
-				state->createPointer(resultId, SIMD::Pointer(routine->descriptorSets[d.DescriptorSet], size));
+				createPointer(resultId, SIMD::Pointer(routine->descriptorSets[d.DescriptorSet], size));
 			}
 			else
 			{
-				state->createPointer(resultId, SIMD::Pointer(nullptr, 0));
+				createPointer(resultId, SIMD::Pointer(nullptr, 0));
 			}
 		}
 		break;
 	case spv::StorageClassPushConstant:
 		{
-			state->createPointer(resultId, SIMD::Pointer(routine->pushConstants, vk::MAX_PUSH_CONSTANT_SIZE));
+			createPointer(resultId, SIMD::Pointer(routine->pushConstants, vk::MAX_PUSH_CONSTANT_SIZE));
 		}
 		break;
 	default:
@@ -232,7 +231,7 @@
 	if(insn.wordCount() > 4)
 	{
 		Object::ID initializerId = insn.word(4);
-		if(getObject(initializerId).kind != Object::Kind::Constant)
+		if(shader.getObject(initializerId).kind != Object::Kind::Constant)
 		{
 			UNIMPLEMENTED("b/148241854: Non-constant initializers not yet implemented");  // FIXME(b/148241854)
 		}
@@ -245,13 +244,15 @@
 		case spv::StorageClassWorkgroup:
 			{
 				bool interleavedByLane = IsStorageInterleavedByLane(objectTy.storageClass);
-				auto ptr = GetPointerToData(resultId, 0, false, state);
-				Operand initialValue(this, state, initializerId);
-				VisitMemoryObject(resultId, false, [&](const MemoryElement &el) {
+				auto ptr = GetPointerToData(resultId, 0, false);
+				Operand initialValue(shader, *this, initializerId);
+
+				shader.VisitMemoryObject(resultId, false, [&](const MemoryElement &el) {
 					auto p = GetElementPointer(ptr, el.offset, interleavedByLane);
 					auto robustness = OutOfBoundsBehavior::UndefinedBehavior;  // Local variables are always within bounds.
-					p.Store(initialValue.Float(el.index), robustness, state->activeLaneMask());
+					p.Store(initialValue.Float(el.index), robustness, activeLaneMask());
 				});
+
 				if(objectTy.storageClass == spv::StorageClassWorkgroup)
 				{
 					// Initialization of workgroup memory is done by each subgroup and requires waiting on a barrier.
@@ -268,24 +269,24 @@
 	return EmitResult::Continue;
 }
 
-SpirvShader::EmitResult SpirvShader::EmitCopyMemory(InsnIterator insn, EmitState *state) const
+SpirvShader::EmitResult SpirvShader::EmitState::EmitCopyMemory(InsnIterator insn)
 {
 	Object::ID dstPtrId = insn.word(1);
 	Object::ID srcPtrId = insn.word(2);
-	auto &dstPtrTy = getObjectType(dstPtrId);
-	auto &srcPtrTy = getObjectType(srcPtrId);
+	auto &dstPtrTy = shader.getObjectType(dstPtrId);
+	auto &srcPtrTy = shader.getObjectType(srcPtrId);
 	ASSERT(dstPtrTy.element == srcPtrTy.element);
 
 	bool dstInterleavedByLane = IsStorageInterleavedByLane(dstPtrTy.storageClass);
 	bool srcInterleavedByLane = IsStorageInterleavedByLane(srcPtrTy.storageClass);
-	auto dstPtr = GetPointerToData(dstPtrId, 0, false, state);
-	auto srcPtr = GetPointerToData(srcPtrId, 0, false, state);
+	auto dstPtr = GetPointerToData(dstPtrId, 0, false);
+	auto srcPtr = GetPointerToData(srcPtrId, 0, false);
 
 	std::unordered_map<uint32_t, uint32_t> srcOffsets;
 
-	VisitMemoryObject(srcPtrId, false, [&](const MemoryElement &el) { srcOffsets[el.index] = el.offset; });
+	shader.VisitMemoryObject(srcPtrId, false, [&](const MemoryElement &el) { srcOffsets[el.index] = el.offset; });
 
-	VisitMemoryObject(dstPtrId, false, [&](const MemoryElement &el) {
+	shader.VisitMemoryObject(dstPtrId, false, [&](const MemoryElement &el) {
 		auto it = srcOffsets.find(el.index);
 		ASSERT(it != srcOffsets.end());
 		auto srcOffset = it->second;
@@ -297,15 +298,15 @@
 		// TODO(b/131224163): Optimize based on src/dst storage classes.
 		auto robustness = OutOfBoundsBehavior::RobustBufferAccess;
 
-		auto value = src.Load<SIMD::Float>(robustness, state->activeLaneMask());
-		dst.Store(value, robustness, state->activeLaneMask());
+		auto value = src.Load<SIMD::Float>(robustness, activeLaneMask());
+		dst.Store(value, robustness, activeLaneMask());
 	});
 	return EmitResult::Continue;
 }
 
-SpirvShader::EmitResult SpirvShader::EmitMemoryBarrier(InsnIterator insn, EmitState *state) const
+SpirvShader::EmitResult SpirvShader::EmitState::EmitMemoryBarrier(InsnIterator insn)
 {
-	auto semantics = spv::MemorySemanticsMask(GetConstScalarInt(insn.word(2)));
+	auto semantics = spv::MemorySemanticsMask(shader.GetConstScalarInt(insn.word(2)));
 	// TODO(b/176819536): We probably want to consider the memory scope here.
 	// For now, just always emit the full fence.
 	Fence(semantics);
@@ -406,19 +407,18 @@
 	}
 }
 
-SIMD::Pointer SpirvShader::GetPointerToData(Object::ID id, SIMD::Int arrayIndices, bool nonUniform, const EmitState *state) const
+SIMD::Pointer SpirvShader::EmitState::GetPointerToData(Object::ID id, SIMD::Int arrayIndices, bool nonUniform) const
 {
-	auto routine = state->routine;
-	auto &object = getObject(id);
+	auto &object = shader.getObject(id);
 	switch(object.kind)
 	{
 	case Object::Kind::Pointer:
 	case Object::Kind::InterfaceVariable:
-		return state->getPointer(id);
+		return getPointer(id);
 
 	case Object::Kind::DescriptorSet:
 		{
-			const auto &d = descriptorDecorations.at(id);
+			const auto &d = shader.descriptorDecorations.at(id);
 			ASSERT(d.DescriptorSet >= 0 && static_cast<uint32_t>(d.DescriptorSet) < vk::MAX_BOUND_DESCRIPTOR_SETS);
 			ASSERT(d.Binding >= 0);
 			ASSERT(routine->pipelineLayout->getDescriptorCount(d.DescriptorSet, d.Binding) != 0);  // "If descriptorCount is zero this binding entry is reserved and the resource must not be accessed from any stage via this binding within any pipeline using the set layout."
@@ -426,11 +426,11 @@
 			uint32_t bindingOffset = routine->pipelineLayout->getBindingOffset(d.DescriptorSet, d.Binding);
 			uint32_t descriptorSize = routine->pipelineLayout->getDescriptorSize(d.DescriptorSet, d.Binding);
 
-			auto set = state->getPointer(id);
+			auto set = getPointer(id);
 			if(nonUniform)
 			{
 				SIMD::Int descriptorOffset = bindingOffset + descriptorSize * arrayIndices;
-				auto robustness = getOutOfBoundsBehavior(id, state);
+				auto robustness = shader.getOutOfBoundsBehavior(id, routine->pipelineLayout);
 				ASSERT(routine->pipelineLayout->getDescriptorType(d.DescriptorSet, d.Binding) != VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK_EXT);
 
 				std::vector<Pointer<Byte>> pointers(SIMD::Width);
@@ -445,7 +445,7 @@
 				{
 					SIMD::Int dynamicOffsetIndex = SIMD::Int(routine->pipelineLayout->getDynamicOffsetIndex(d.DescriptorSet, d.Binding) + arrayIndices);
 					SIMD::Pointer routineDynamicOffsets = SIMD::Pointer(routine->descriptorDynamicOffsets, 0, sizeof(int) * dynamicOffsetIndex);
-					SIMD::Int dynamicOffsets = routineDynamicOffsets.Load<SIMD::Int>(robustness, state->activeLaneMask());
+					SIMD::Int dynamicOffsets = routineDynamicOffsets.Load<SIMD::Int>(robustness, activeLaneMask());
 					ptr += dynamicOffsets;
 				}
 				return ptr;
@@ -493,24 +493,25 @@
 	}
 }
 
-void SpirvShader::OffsetToElement(SIMD::Pointer &ptr, Object::ID elementId, int32_t arrayStride, const EmitState *state) const
+void SpirvShader::EmitState::OffsetToElement(SIMD::Pointer &ptr, Object::ID elementId, int32_t arrayStride) const
 {
 	if(elementId != 0 && arrayStride != 0)
 	{
-		auto &elementObject = getObject(elementId);
+		auto &elementObject = shader.getObject(elementId);
 		ASSERT(elementObject.kind == Object::Kind::Constant || elementObject.kind == Object::Kind::Intermediate);
+
 		if(elementObject.kind == Object::Kind::Constant)
 		{
-			ptr += GetConstScalarInt(elementId) * arrayStride;
+			ptr += shader.GetConstScalarInt(elementId) * arrayStride;
 		}
 		else
 		{
-			ptr += state->getIntermediate(elementId).Int(0) * arrayStride;
+			ptr += getIntermediate(elementId).Int(0) * arrayStride;
 		}
 	}
 }
 
-void SpirvShader::Fence(spv::MemorySemanticsMask semantics) const
+void SpirvShader::EmitState::Fence(spv::MemorySemanticsMask semantics) const
 {
 	if(semantics != spv::MemorySemanticsMaskNone)
 	{
diff --git a/src/Pipeline/SpirvShaderSampling.cpp b/src/Pipeline/SpirvShaderSampling.cpp
index ee4cca3..c2dbf7c 100644
--- a/src/Pipeline/SpirvShaderSampling.cpp
+++ b/src/Pipeline/SpirvShaderSampling.cpp
@@ -30,7 +30,7 @@
 
 namespace sw {
 
-SpirvShader::ImageSampler *SpirvShader::getImageSampler(const vk::Device *device, uint32_t signature, uint32_t samplerId, uint32_t imageViewId)
+SpirvShader::ImageSampler *SpirvShader::EmitState::getImageSampler(const vk::Device *device, uint32_t signature, uint32_t samplerId, uint32_t imageViewId)
 {
 	ImageInstructionSignature instruction(signature);
 	ASSERT(imageViewId != 0 && (samplerId != 0 || instruction.samplerMethod == Fetch || instruction.samplerMethod == Write));
@@ -125,7 +125,7 @@
 	return (ImageSampler *)(routine->getEntry());
 }
 
-std::shared_ptr<rr::Routine> SpirvShader::emitWriteRoutine(ImageInstructionSignature instruction, const Sampler &samplerState)
+std::shared_ptr<rr::Routine> SpirvShader::EmitState::emitWriteRoutine(ImageInstructionSignature instruction, const Sampler &samplerState)
 {
 	// TODO(b/129523279): Hold a separate mutex lock for the sampler being built.
 	rr::Function<Void(Pointer<Byte>, Pointer<SIMD::Float>, Pointer<SIMD::Float>, Pointer<Byte>)> function;
@@ -141,7 +141,7 @@
 	return function("sampler");
 }
 
-std::shared_ptr<rr::Routine> SpirvShader::emitSamplerRoutine(ImageInstructionSignature instruction, const Sampler &samplerState)
+std::shared_ptr<rr::Routine> SpirvShader::EmitState::emitSamplerRoutine(ImageInstructionSignature instruction, const Sampler &samplerState)
 {
 	// TODO(b/129523279): Hold a separate mutex lock for the sampler being built.
 	rr::Function<Void(Pointer<Byte>, Pointer<SIMD::Float>, Pointer<SIMD::Float>, Pointer<Byte>)> function;
@@ -263,7 +263,7 @@
 	return function("sampler");
 }
 
-sw::FilterType SpirvShader::convertFilterMode(const vk::SamplerState *samplerState, VkImageViewType imageViewType, SamplerMethod samplerMethod)
+sw::FilterType SpirvShader::EmitState::convertFilterMode(const vk::SamplerState *samplerState, VkImageViewType imageViewType, SamplerMethod samplerMethod)
 {
 	if(samplerMethod == Gather)
 	{
@@ -316,7 +316,7 @@
 	return FILTER_POINT;
 }
 
-sw::MipmapType SpirvShader::convertMipmapMode(const vk::SamplerState *samplerState)
+sw::MipmapType SpirvShader::EmitState::convertMipmapMode(const vk::SamplerState *samplerState)
 {
 	if(!samplerState)
 	{
@@ -339,7 +339,7 @@
 	}
 }
 
-sw::AddressingMode SpirvShader::convertAddressingMode(int coordinateIndex, const vk::SamplerState *samplerState, VkImageViewType imageViewType)
+sw::AddressingMode SpirvShader::EmitState::convertAddressingMode(int coordinateIndex, const vk::SamplerState *samplerState, VkImageViewType imageViewType)
 {
 	switch(imageViewType)
 	{