Method emitControlFlowDivergence

GPCS4/Graphics/Gcn/GcnCompilerFlowControl.cpp:230–263

	}

	uint32_t GcnCompiler::emitControlFlowDivergence()
	{
		uint32_t result = 0;

		const uint32_t utypeId = getScalarTypeId(GcnScalarType::Uint32);
		const uint32_t btypeId = m_module.defBoolType();
		// We cheat the shader as if the CU only provide one single thread,
		// so we only set EXEC bit against invocation id.
		if (m_moduleInfo.options.separateSubgroup)
		{
			auto mask = emitCommonSystemValueLoad(
				GcnSystemValue::SubgroupEqMask, GcnRegMask::select(0));
			// For non-compute shader, we only use low 32 bits of exec.
			auto exec  = m_state.exec.emitLoad(GcnRegMask::select(0));
			auto value = m_module.opBitwiseAnd(utypeId, exec.low.id, mask.id);
			result     = m_module.opINotEqual(btypeId, value, m_module.constu32(0));
		}
		else
		{
			auto mask = emitCommonSystemValueLoad(
				GcnSystemValue::SubgroupEqMask, GcnRegMask::firstN(2));

			auto exec = m_state.exec.emitLoad(GcnRegMask::firstN(2));

			auto maskX   = emitRegisterExtract(mask, GcnRegMask::select(0));
			auto maskY   = emitRegisterExtract(mask, GcnRegMask::select(1));
			auto valueX  = m_module.opBitwiseAnd(utypeId, exec.low.id, maskX.id);
			auto valueY  = m_module.opBitwiseAnd(utypeId, exec.high.id, maskY.id);
			auto resultX = m_module.opINotEqual(btypeId, valueX, m_module.constu32(0));
			auto resultY = m_module.opINotEqual(btypeId, valueY, m_module.constu32(0));
			result       = m_module.opLogicalOr(btypeId, resultX, resultY);
		}
		return result;
	}

	uint32_t GcnCompiler::emitControlFlowCondition(const GcnTokenCondition& condition)
	{