Merge pull request #29 from Unity-Technologies/upstream

Pulled changes from internal unity repo at changeset 42ec4a54d7ca

Author: strandborg

include/ShaderInfo.h

@@ -451,6 +451,8 @@ class ShaderInfo
 
 	static ResourceGroup ResourceTypeToResourceGroup(ResourceType);
 
+    static uint32_t GetCBVarSize(const ShaderVarType* psType, bool matrixAsVectors, bool wholeArraySize = false);
+
 	static int GetShaderVarFromOffset(const uint32_t ui32Vec4Offset,
 		const uint32_t (&pui32Swizzle)[4],
 		const ConstantBuffer* psCBuf,
@@ -460,7 +462,7 @@ class ShaderInfo
 		int32_t* pi32Rebase,
 		uint32_t flags);
 
-	static std::string GetShaderVarIndexedFullName(const ShaderVarType* psShaderVar, std::vector<uint32_t> &indices);
+	static std::string GetShaderVarIndexedFullName(const ShaderVarType* psShaderVar, std::vector<uint32_t> &indices, const std::string dynamicIndex, bool revertDynamicIndexCalc, bool matrixAsVectors);
 
 	// Apply shader precision information to resource bindings
 	void AddSamplerPrecisions(HLSLccSamplerPrecisionInfo &info);

include/hlslcc.h

@@ -444,15 +444,21 @@ static const unsigned int HLSLCC_FLAG_VULKAN_BINDINGS = 0x40000;
 // If set, metal output will use linear sampler for shadow compares, otherwise point sampler.
 static const unsigned int HLSLCC_FLAG_METAL_SHADOW_SAMPLER_LINEAR = 0x80000;
 
-// If set, emits for NVN, the Nvidia-provided graphics API for Nintendo Switch.
-static const unsigned int HLSLCC_FLAG_NVN_TARGET = 0x100000; 
+// If set, avoid emit atomic counter (ARB_shader_atomic_counters) and use atomic functions provided by ARB_shader_storage_buffer_object instead.
+static const unsigned int HLSLCC_FLAG_AVOID_SHADER_ATOMIC_COUNTERS = 0x100000; 
 
 // If set, and generating Vulkan shaders, attempts to detect static branching and transforms them into specialization constants
 static const unsigned int HLSLCC_FLAG_VULKAN_SPECIALIZATION_CONSTANTS = 0x200000;
 
 // If set, this shader uses the GLSL extension EXT_shader_framebuffer_fetch
 static const unsigned int HLSLCC_FLAG_SHADER_FRAMEBUFFER_FETCH = 0x400000;
 
+// Build for Switch.
+static const unsigned int HLSLCC_FLAG_NVN_TARGET = 0x800000;
+
+// If set, generate an instance name for constant buffers. GLSL specs 4.5 disallows uniform variables from different constant buffers sharing the same name
+// as long as they are part of the same final linked program. Uniform buffer instance names solve this cross-shader symbol conflict issue.
+static const unsigned int HLSLCC_FLAG_UNIFORM_BUFFER_OBJECT_WITH_INSTANCE_NAME = 0x1000000;
 
 #ifdef __cplusplus
 extern "C" {

src/DataTypeAnalysis.cpp

@@ -315,13 +315,6 @@ void HLSLcc::DataTypeAnalysis::SetDataTypes(HLSLCrossCompilerContext* psContext,
 				MarkOperandAs(&psInst->asOperands[2], SVT_INT_AMBIGUOUS, aeTempVecType);
 				break;
 
-			case OPCODE_AND:
-				MarkOperandAs(&psInst->asOperands[0], SVT_INT_AMBIGUOUS, aeTempVecType);
-				MarkOperandAs(&psInst->asOperands[1], SVT_BOOL, aeTempVecType);
-				MarkOperandAs(&psInst->asOperands[2], SVT_BOOL, aeTempVecType);
-				break;
-
-
 			case OPCODE_IF:
 			case OPCODE_BREAKC:
 			case OPCODE_CALLC:
@@ -344,12 +337,18 @@ void HLSLcc::DataTypeAnalysis::SetDataTypes(HLSLCrossCompilerContext* psContext,
 				MarkOperandAs(&psInst->asOperands[2], SVT_UINT, aeTempVecType);
 				break;
 
+			case OPCODE_AND:
+			case OPCODE_OR:
+				MarkOperandAs(&psInst->asOperands[0], SVT_INT_AMBIGUOUS, aeTempVecType);
+				MarkOperandAs(&psInst->asOperands[1], SVT_BOOL, aeTempVecType);
+				MarkOperandAs(&psInst->asOperands[2], SVT_BOOL, aeTempVecType);
+				break;
+
 				// Integer ops that don't care of signedness
 			case OPCODE_IADD:
 			case OPCODE_INEG:
 			case OPCODE_ISHL:
 			case OPCODE_NOT:
-			case OPCODE_OR:
 			case OPCODE_XOR:
 			case OPCODE_BUFINFO:
 			case OPCODE_COUNTBITS:
@@ -673,7 +672,9 @@ void HLSLcc::DataTypeAnalysis::SetDataTypes(HLSLCrossCompilerContext* psContext,
 						}
 					}
 
-					if (foundImmediate && dataType == SVT_VOID)
+					// Use at minimum int type when any operand is immediate.
+					// Allowing bool could lead into bugs like case 883080
+					if (foundImmediate && (dataType == SVT_VOID || dataType == SVT_BOOL))
 						dataType = SVT_INT;
 
 					if (dataType != SVT_VOID)

src/HLSLCrossCompilerContext.cpp

@@ -101,7 +101,9 @@ void HLSLCrossCompilerContext::RequireExtension(const std::string &extName)
 		return;
 
 	m_EnabledExtensions.insert(extName);
+    bformata(extensions, "#ifdef %s\n", extName.c_str());
 	bformata(extensions, "#extension %s : require\n", extName.c_str());
+    bcatcstr(extensions, "#endif\n");
 }
 
 std::string HLSLCrossCompilerContext::GetDeclaredInputName(const Operand* psOperand, int *piRebase, int iIgnoreRedirect, uint32_t *puiIgnoreSwizzle) const

src/HLSLccToolkit.cpp

@@ -457,11 +457,13 @@ namespace HLSLcc
 		return false;
 	}
 
+#ifndef fpcheck
 #ifdef _MSC_VER
 #define fpcheck(x) (_isnan(x) || !_finite(x))
 #else
 #define fpcheck(x) (std::isnan(x) || std::isinf(x))
 #endif
+#endif // #ifndef fpcheck
 
 	// Helper function to print floats with full precision
 	void PrintFloat(bstring b, float f)

src/Operand.cpp

@@ -476,12 +476,11 @@ SHADER_VARIABLE_TYPE Operand::GetDataType(HLSLCrossCompilerContext* psContext, S
 		const ShaderVarType* psVarType = NULL;
 		int32_t rebase = -1;
 		bool isArray;
-		int foundVar;
 		psContext->psShader->sInfo.GetConstantBufferFromBindingPoint(RGROUP_CBUFFER, aui32ArraySizes[0], &psCBuf);
 		if (psCBuf)
 		{
-			foundVar = ShaderInfo::GetShaderVarFromOffset(aui32ArraySizes[1], aui32Swizzle, psCBuf, &psVarType, &isArray, NULL, &rebase, psContext->flags);
-			if (foundVar && m_SubOperands[1].get() == NULL) // TODO: why this suboperand thing?
+			int foundVar = ShaderInfo::GetShaderVarFromOffset(aui32ArraySizes[1], aui32Swizzle, psCBuf, &psVarType, &isArray, NULL, &rebase, psContext->flags);
+			if (foundVar)
 			{
 				return psVarType->Type;
 			}
@@ -584,4 +583,67 @@ int Operand::GetNumInputElements(const HLSLCrossCompilerContext *psContext) cons
 
 	// TODO: Are there ever any cases where the mask has 'holes'?
 	return HLSLcc::GetNumberBitsSet(psSig->ui32Mask);
+}
+
+Operand* Operand::GetDynamicIndexOperand(HLSLCrossCompilerContext *psContext, const ShaderVarType* psVar, bool isAoS, bool *needsIndexCalcRevert) const
+{
+    Operand *psDynIndexOp = m_SubOperands[0].get();
+    if (psDynIndexOp == NULL)
+        psDynIndexOp = m_SubOperands[1].get();
+
+    *needsIndexCalcRevert = false;
+    if (psDynIndexOp != NULL && isAoS)
+    {
+        // if dynamically indexing array of structs, try using the original index var before the float4 address calc
+        bool indexVarFound = false;
+        *needsIndexCalcRevert = true;
+        Instruction *psDynIndexOrigin = psDynIndexOp->m_Defines[0].m_Inst;
+        Operand *asOps = psDynIndexOrigin->asOperands;
+        Operand *psOriginOp = NULL;
+
+        // DXBC always addresses as float4, find the address calculation
+
+        // Special case where struct is float4 size, no extra calc is done
+        if (ShaderInfo::GetCBVarSize(psVar->Parent, true) <= 16) // matrixAsVectors arg does not matter here as with matrices the size will go over the limit anyway
+        {
+            indexVarFound = true;
+            *needsIndexCalcRevert = false;
+        }
+        else if (psDynIndexOrigin->eOpcode == OPCODE_IMUL)
+        {
+            // check which one of the src operands is the original index
+            if ((asOps[2].eType == OPERAND_TYPE_TEMP || asOps[2].eType == OPERAND_TYPE_INPUT) && asOps[3].eType == OPERAND_TYPE_IMMEDIATE32)
+                psOriginOp = &asOps[2];
+            else if ((asOps[3].eType == OPERAND_TYPE_TEMP || asOps[3].eType == OPERAND_TYPE_INPUT) &&  asOps[2].eType == OPERAND_TYPE_IMMEDIATE32)
+                psOriginOp = &asOps[3];
+        }
+        else if (psDynIndexOrigin->eOpcode == OPCODE_ISHL)
+        {
+            if (asOps[2].eType == OPERAND_TYPE_IMMEDIATE32)
+                psOriginOp = &asOps[1];
+        }
+
+        if (psOriginOp != NULL)
+        {
+            indexVarFound = true;
+
+            // Check if the mul dest is not the same temp as the src. Also check that the temp 
+            // does not have multiple uses (which could override the value)
+            // -> we can use src straight and no index revert calc is needed
+            if ((psOriginOp->eType == OPERAND_TYPE_INPUT)
+                || ((psOriginOp->ui32RegisterNumber != psDynIndexOp->ui32RegisterNumber || psOriginOp->GetDataType(psContext) != psDynIndexOp->GetDataType(psContext))
+                    && psOriginOp->m_Defines[0].m_Inst->m_Uses.size() == 1))
+            {
+                psDynIndexOp = psOriginOp;
+                *needsIndexCalcRevert = false;
+            }
+        }
+
+        // Atm we support only this very basic case of dynamic indexing array of structs.
+        // Return error if something else is encountered.
+        if (!indexVarFound)
+            psContext->m_Reflection.OnDiagnostics("Unsupported dynamic indexing scheme on constant buffer vars.", 0, true);
+    }
+
+    return psDynIndexOp;
 }

src/ShaderInfo.cpp

@@ -150,29 +150,37 @@ int ShaderInfo::GetOutputSignatureFromSystemValue(SPECIAL_NAME eSystemValueType,
 	return 0;
 }
 
-static uint32_t GetCBVarSize(const ShaderVarType* psType, bool matrixAsVectors)
+uint32_t ShaderInfo::GetCBVarSize(const ShaderVarType* psType, bool matrixAsVectors, bool wholeArraySize)
 {
-	// Struct size is calculated from the offset and size of its last member
+    // Default is regular matrices, vectors and scalars 
+    uint32_t size = psType->Columns * psType->Rows * 4;
+
+	// Struct size is calculated from the offset and size of its last member.
+    // Need to take into account that members could be arrays.
 	if (psType->Class == SVC_STRUCT)
 	{
-		return psType->Members.back().Offset + GetCBVarSize(&psType->Members.back(), matrixAsVectors);
+        size = psType->Members.back().Offset + GetCBVarSize(&psType->Members.back(), matrixAsVectors, true);
 	}
-
 	// Matrices represented as vec4 arrays have special size calculation 
-	if (matrixAsVectors)
+	else if (matrixAsVectors)
 	{
 		if (psType->Class == SVC_MATRIX_ROWS)
 		{
-			return psType->Rows * 16;
+            size = psType->Rows * 16;
 		}
 		else if (psType->Class == SVC_MATRIX_COLUMNS)
 		{
-			return psType->Columns * 16;
+			size = psType->Columns * 16;
 		}
 	}
 
-	// Regular matrices, vectors and scalars 
-	return psType->Columns * psType->Rows * 4;
+    if (wholeArraySize && psType->Elements > 1)
+    { 
+        uint32_t paddedSize = ((size + 15) / 16) * 16; // Arrays are padded to float4 size
+        size = (psType->Elements - 1) * paddedSize + size; // Except the last element
+    }
+
+    return size;
 }
 
 static const ShaderVarType* IsOffsetInType(const ShaderVarType* psType,
@@ -184,10 +192,8 @@ static const ShaderVarType* IsOffsetInType(const ShaderVarType* psType,
 	uint32_t flags)
 {
 	uint32_t thisOffset = parentOffset + psType->Offset;
-	uint32_t thisSize = GetCBVarSize(psType, (flags & HLSLCC_FLAG_TRANSLATE_MATRICES) != 0);
-	uint32_t paddedSize = thisSize;
-	if (thisSize % 16 > 0) 
-		paddedSize += (16 - (thisSize % 16));
+	uint32_t thisSize = ShaderInfo::GetCBVarSize(psType, (flags & HLSLCC_FLAG_TRANSLATE_MATRICES) != 0);
+	uint32_t paddedSize = ((thisSize + 15) / 16) * 16;
 	uint32_t arraySize = thisSize;
 
 	// Array elements are padded to align on vec4 size, except for the last one
@@ -308,7 +314,7 @@ int ShaderInfo::GetShaderVarFromOffset(const uint32_t ui32Vec4Offset,
 
 // Patches the fullName of the var with given array indices. Does not insert the indexing for the var itself if it is an array.
 // Searches for brackets and inserts indices one by one.
-std::string ShaderInfo::GetShaderVarIndexedFullName(const ShaderVarType* psShaderVar, std::vector<uint32_t> &indices)
+std::string ShaderInfo::GetShaderVarIndexedFullName(const ShaderVarType* psShaderVar, std::vector<uint32_t> &indices, const std::string dynamicIndex, bool revertDynamicIndexCalc, bool matrixAsVectors)
 {
 	std::ostringstream oss;
 	size_t prevpos = 0;
@@ -318,8 +324,29 @@ std::string ShaderInfo::GetShaderVarIndexedFullName(const ShaderVarType* psShade
 	{
 		pos++;
 		oss << psShaderVar->fullName.substr(prevpos, pos - prevpos);
-		if (i < indices.size())
+
+        // Add possibly given dynamic index for the root array.
+        if (i == 0 && !dynamicIndex.empty())
+        {
+            oss << dynamicIndex;
+
+            // if we couldn't use original index temp, revert the float4 address calc here
+            if (revertDynamicIndexCalc)
+            {
+                const ShaderVarType* psRootVar = psShaderVar;
+                while (psRootVar->Parent != NULL)
+                    psRootVar = psRootVar->Parent;
+
+                uint32_t thisSize = (GetCBVarSize(psRootVar, matrixAsVectors) + 15) / 16; // size in float4
+                oss << " / " << thisSize;
+            }
+
+            if (!indices.empty() && indices[i] != 0)
+                oss << " + " << indices[i];
+        }
+		else if (i < indices.size())
 			oss << indices[i];
+
 		prevpos = pos;
 		i++;
 		pos = psShaderVar->fullName.find('[', prevpos);

src/internal_includes/Operand.h

@@ -92,6 +92,11 @@ class Operand
 	// Same as above but with explicit shader type and phase
 	int GetRegisterSpace(SHADER_TYPE eShaderType, SHADER_PHASE_TYPE eShaderPhaseType) const;
 
+    // Find the operand that contains the dynamic index for this operand (array in constant buffer).
+    // When isAoS is true, we'll try to find the original index var to avoid additional calculations.
+    // needsIndexCalcRevert output will tell if we need to divide the value to get the correct index.
+    Operand* GetDynamicIndexOperand(HLSLCrossCompilerContext *psContext, const ShaderVarType* psVar, bool isAoS, bool *needsIndexCalcRevert) const;
+
 	// Maps REFLECT_RESOURCE_PRECISION into OPERAND_MIN_PRECISION as much as possible
 	static OPERAND_MIN_PRECISION ResourcePrecisionToOperandPrecision(REFLECT_RESOURCE_PRECISION ePrec);
 

src/internal_includes/toGLSLOperand.h

@@ -21,4 +21,6 @@ std::string ResourceName(HLSLCrossCompilerContext* psContext, ResourceGroup grou
 std::string TextureSamplerName(ShaderInfo* psShaderInfo, const uint32_t ui32TextureRegisterNumber, const uint32_t ui32SamplerRegisterNumber, const int bZCompare);
 void ConcatTextureSamplerName(bstring str, ShaderInfo* psShaderInfo, const uint32_t ui32TextureRegisterNumber, const uint32_t ui32SamplerRegisterNumber, const int bZCompare);
 
+std::string UniformBufferInstanceName(HLSLCrossCompilerContext* psContext, const std::string& name);
+
 #endif

src/internal_includes/toMetal.h

@@ -165,6 +165,8 @@ class ToMetal : public Translator
 	void AddComparison(Instruction* psInst, ComparisonType eType,
 		uint32_t typeFlag);
 
+	bool CanForceToHalfOperand(const Operand *psOperand);
+
 	void AddMOVBinaryOp(const Operand *pDest, Operand *pSrc);
 	void AddMOVCBinaryOp(const Operand *pDest, const Operand *src0, Operand *src1, Operand *src2);
 	void CallBinaryOp(const char* name, Instruction* psInst,