Merge pull request #48 from Unity-Technologies/upstream-update

bring latest changes from upstream ( f60ac47e0193 )

Author: aet

include/UnityInstancingFlexibleArraySize.h

@@ -4,12 +4,20 @@
 
 #include <string>
 #define UNITY_RUNTIME_INSTANCING_ARRAY_SIZE_MACRO "UNITY_RUNTIME_INSTANCING_ARRAY_SIZE"
+#define UNITY_PRETRANSFORM_CONSTANT_NAME "UnityDisplayOrientationPreTransform"
 
 const unsigned int kArraySizeConstantID = 0;
+const unsigned int kPreTransformConstantID = 1;
 
 // TODO: share with Runtime/GfxDevice/InstancingUtilities.h
 inline bool IsUnityInstancingConstantBufferName(const char* cbName)
 {
     static const char kInstancedCbNamePrefix[] = "UnityInstancing";
     return strncmp(cbName, kInstancedCbNamePrefix, sizeof(kInstancedCbNamePrefix) - 1) == 0;
 }
+
+inline bool IsPreTransformConstantBufferName(const char* cbName)
+{
+    static const char kPreTransformCbNamePrefix[] = "UnityDisplayOrientationPreTransformData";
+    return strncmp(cbName, kPreTransformCbNamePrefix, sizeof(kPreTransformCbNamePrefix) - 1) == 0;
+}

include/hlslcc.h

@@ -678,7 +678,7 @@ typedef uint_least64_t uint_fast64_t;
 # elif defined(__i386__) || defined(_WIN32) || defined(WIN32)
 #  define stdint_intptr_bits 32
 # elif defined(__INTEL_COMPILER)
-/* TODO -- what did Intel do about x86-64? */
+#error Unknown compiler
 # endif
 
 # ifdef stdint_intptr_bits
@@ -711,9 +711,7 @@ typedef uint_least64_t uint_fast64_t;
 typedef stdint_intptr_glue3 (uint, stdint_intptr_bits, _t) uintptr_t;
 typedef stdint_intptr_glue3 (int, stdint_intptr_bits, _t)  intptr_t;
 # else
-/* TODO -- This following is likely wrong for some platforms, and does
-   nothing for the definition of uintptr_t. */
-typedef ptrdiff_t intptr_t;
+#error Unknown compiler
 # endif
 # define STDINT_H_UINTPTR_T_DEFINED
 #endif

include/pstdint.h

@@ -9,15 +9,15 @@
 using namespace HLSLcc::ControlFlow;
 using HLSLcc::ForEachOperand;
 
-const BasicBlock &ControlFlowGraph::Build(const Instruction *firstInstruction)
+const BasicBlock &ControlFlowGraph::Build(const Instruction* firstInstruction, const Instruction* endInstruction)
 {
     using std::for_each;
 
     m_BlockMap.clear();
     m_BlockStorage.clear();
 
     // Self-registering into m_BlockStorage so it goes out of the scope when ControlFlowGraph does
-    BasicBlock *root = new BasicBlock(Utils::GetNextNonLabelInstruction(firstInstruction), *this, NULL);
+    BasicBlock *root = new BasicBlock(Utils::GetNextNonLabelInstruction(firstInstruction), *this, NULL, endInstruction);
 
     // Build the reachable set for each block
     bool hadChanges;
@@ -58,10 +58,11 @@ BasicBlock *ControlFlowGraph::GetBasicBlockForInstruction(const Instruction *ins
 
 // Generate a basic block. Private constructor, can only be constructed from ControlFlowGraph::Build().
 // Auto-registers itself into ControlFlowGraph
-BasicBlock::BasicBlock(const Instruction *psFirst, ControlFlowGraph &graph, const Instruction *psPrecedingBlockHead)
+BasicBlock::BasicBlock(const Instruction *psFirst, ControlFlowGraph &graph, const Instruction *psPrecedingBlockHead, const Instruction* endInstruction)
     : m_Graph(graph)
     , m_First(psFirst)
     , m_Last(NULL)
+    , m_End(endInstruction)
 {
     m_UEVar.clear();
     m_VarKill.clear();
@@ -94,7 +95,7 @@ BasicBlock::BasicBlock(const Instruction *psFirst, ControlFlowGraph &graph, cons
 void BasicBlock::Build()
 {
     const Instruction *inst = m_First;
-    while (1)
+    while (inst != m_End)
     {
         // Process sources first
         ForEachOperand(inst, inst + 1, FEO_FLAG_SRC_OPERAND | FEO_FLAG_SUBOPERAND,
@@ -158,7 +159,8 @@ void BasicBlock::Build()
             default:
                 break;
             case OPCODE_RET:
-                blockDone = true;
+                // Continue processing, in the case of unreachable code we still need to translate it properly (case 1160309)
+                // blockDone = true;
                 break;
             case OPCODE_RETC:
                 // Basic block is done, start a next one.
@@ -240,7 +242,7 @@ void BasicBlock::Build()
     m_Reachable = m_DEDef;
 
     // Tag the end of the basic block
-    m_Last = inst;
+    m_Last = std::max(m_First, std::min(inst, m_End - 1));
 //  printf("Basic Block %d -> %d\n", (int)m_First->id, (int)m_Last->id);
 }
 
@@ -256,7 +258,7 @@ BasicBlock * BasicBlock::AddChildBasicBlock(const Instruction *psFirst)
         return b;
     }
     // Otherwise create one. Self-registering and self-connecting
-    return new BasicBlock(psFirst, m_Graph, m_First);
+    return new BasicBlock(psFirst, m_Graph, m_First, m_End);
 }
 
 bool BasicBlock::RebuildReachable()
@@ -334,6 +336,7 @@ void BasicBlock::RVarUnion(ReachableVariables &a, const ReachableVariables &b)
 #if ENABLE_UNIT_TESTS
 
 #define UNITY_EXTERNAL_TOOL 1
+#include "Projects/PrecompiledHeaders/UnityPrefix.h" // Needed for defines such as ENABLE_CPP_EXCEPTIONS
 #include "Testing.h" // From Runtime/Testing
 
 UNIT_TEST_SUITE(HLSLcc)
@@ -348,7 +351,7 @@ UNIT_TEST_SUITE(HLSLcc)
         };
 
         ControlFlowGraph cfg;
-        const BasicBlock &root = cfg.Build(inst);
+        const BasicBlock &root = cfg.Build(inst, inst + ARRAY_SIZE(inst));
 
         CHECK_EQUAL(&inst[0], root.First());
         CHECK_EQUAL(&inst[1], root.Last());
@@ -403,7 +406,7 @@ UNIT_TEST_SUITE(HLSLcc)
         };
 
         ControlFlowGraph cfg;
-        const BasicBlock &root = cfg.Build(inst);
+        const BasicBlock &root = cfg.Build(inst, inst + ARRAY_SIZE(inst));
 
         CHECK_EQUAL(root.First(), &inst[0]);
         CHECK_EQUAL(root.Last(), &inst[2]);
@@ -539,7 +542,7 @@ UNIT_TEST_SUITE(HLSLcc)
         };
 
         ControlFlowGraph cfg;
-        const BasicBlock &root = cfg.Build(inst);
+        const BasicBlock &root = cfg.Build(inst, inst + ARRAY_SIZE(inst));
 
         CHECK_EQUAL(&inst[0], root.First());
         CHECK_EQUAL(&inst[4], root.Last());
@@ -699,7 +702,7 @@ UNIT_TEST_SUITE(HLSLcc)
         };
 
         ControlFlowGraph cfg;
-        const BasicBlock &root = cfg.Build(inst);
+        const BasicBlock &root = cfg.Build(inst, inst + ARRAY_SIZE(inst));
 
         CHECK_EQUAL(&inst[0], root.First());
         CHECK_EQUAL(&inst[2], root.Last());

src/ControlFlowGraph.cpp

@@ -430,13 +430,17 @@ void HLSLcc::DataTypeAnalysis::SetDataTypes(HLSLCrossCompilerContext* psContext,
 
                 case OPCODE_LD:
                 case OPCODE_LD_MS:
-                    // TODO: Would need to know the sampler return type
-                    MarkOperandAs(&psInst->asOperands[0], SVT_FLOAT, aeTempVecType);
+                {
+                    SHADER_VARIABLE_TYPE samplerReturnType = psInst->asOperands[2].aeDataType[0];
+                    MarkOperandAs(&psInst->asOperands[0], samplerReturnType, aeTempVecType);
                     MarkOperandAs(&psInst->asOperands[1], SVT_UINT, aeTempVecType);
                     break;
+                }
 
                 case OPCODE_MOVC:
                     MarkOperandAs(&psInst->asOperands[1], SVT_BOOL, aeTempVecType);
+                    break;
+
                 case OPCODE_SWAPC:
                     MarkOperandAs(&psInst->asOperands[2], SVT_BOOL, aeTempVecType);
                     break;
@@ -455,6 +459,7 @@ void HLSLcc::DataTypeAnalysis::SetDataTypes(HLSLCrossCompilerContext* psContext,
                             MarkOperandAs(&psInst->asOperands[0], SVT_UINT, aeTempVecType);
                             break;
                     }
+                    break;
 
                 case OPCODE_SAMPLE_INFO:
                     // Sample_info uses the same RESINFO_RETURN_TYPE for storage. 0 = float, 1 = uint.
@@ -594,28 +599,29 @@ void HLSLcc::DataTypeAnalysis::SetDataTypes(HLSLCrossCompilerContext* psContext,
                 case OPCODE_DCL_RESOURCE_STRUCTURED:
                 case OPCODE_SYNC:
 
-                // TODO
-                case OPCODE_DADD:
-                case OPCODE_DMAX:
-                case OPCODE_DMIN:
-                case OPCODE_DMUL:
-                case OPCODE_DEQ:
-                case OPCODE_DGE:
-                case OPCODE_DLT:
-                case OPCODE_DNE:
-                case OPCODE_DMOV:
-                case OPCODE_DMOVC:
-                case OPCODE_DTOF:
-                case OPCODE_FTOD:
-
                 case OPCODE_EVAL_SNAPPED:
                 case OPCODE_EVAL_SAMPLE_INDEX:
                 case OPCODE_EVAL_CENTROID:
 
                 case OPCODE_DCL_GS_INSTANCE_COUNT:
 
                 case OPCODE_ABORT:
-                case OPCODE_DEBUG_BREAK:*/
+                case OPCODE_DEBUG_BREAK:
+
+                 // Double not supported
+                 case OPCODE_DADD:
+                 case OPCODE_DMAX:
+                 case OPCODE_DMIN:
+                 case OPCODE_DMUL:
+                 case OPCODE_DEQ:
+                 case OPCODE_DGE:
+                 case OPCODE_DLT:
+                 case OPCODE_DNE:
+                 case OPCODE_DMOV:
+                 case OPCODE_DMOVC:
+                 case OPCODE_DTOF:
+                 case OPCODE_FTOD:
+                 */
 
                 default:
                     break;

src/DataTypeAnalysis.cpp

@@ -7,6 +7,7 @@
 #include "internal_includes/debug.h"
 #include "internal_includes/Translator.h"
 #include "internal_includes/ControlFlowGraph.h"
+#include "internal_includes/languages.h"
 #include "include/hlslcc.h"
 #include <sstream>
 
@@ -49,8 +50,8 @@ void HLSLCrossCompilerContext::DoDataTypeAnalysis(ShaderPhase *psPhase)
 
         CalculateStandaloneDefinitions(duChains, psPhase->ui32TotalTemps);
 
-        // Only do sampler precision downgrade on pixel shaders.
-        if (psShader->eShaderType == PIXEL_SHADER)
+        // Only do sampler precision downgrade with pixel shaders on mobile targets / Switch
+        if (psShader->eShaderType == PIXEL_SHADER && (IsMobileTarget(this) || IsSwitch()))
             UpdateSamplerPrecisions(psShader->sInfo, duChains, psPhase->ui32TotalTemps);
 
         UDSplitTemps(&psPhase->ui32TotalTemps, duChains, udChains, psPhase->pui32SplitInfo);
@@ -64,6 +65,55 @@ void HLSLCrossCompilerContext::DoDataTypeAnalysis(ShaderPhase *psPhase)
         psPhase->psTempDeclaration->value.ui32NumTemps = psPhase->ui32TotalTemps;
 }
 
+void HLSLCrossCompilerContext::ReserveFramebufferFetchInputs()
+{
+    if (psShader->eShaderType != PIXEL_SHADER)
+        return;
+
+    if (!psShader->extensions->EXT_shader_framebuffer_fetch)
+        return;
+
+    if ((flags & HLSLCC_FLAG_SHADER_FRAMEBUFFER_FETCH) == 0)
+        return;
+
+    if (!(psShader->eTargetLanguage >= LANG_ES_300 && psShader->eTargetLanguage <= LANG_ES_LAST))
+        return;
+
+    if (!psDependencies)
+        return;
+
+    if (!HaveUniformBindingsAndLocations(psShader->eTargetLanguage, psShader->extensions, flags) &&
+        ((flags & HLSLCC_FLAG_FORCE_EXPLICIT_LOCATIONS) == 0 || (flags & HLSLCC_FLAG_COMBINE_TEXTURE_SAMPLERS) != 0))
+        return;
+
+    // The Adreno GLSL compiler fails to compile shaders that use the same location for textures and inout attachments
+    // So here we figure out the maximum index of any inout render target and then make sure that we never use those for textures.
+    int maxInOutRenderTargetIndex = -1;
+    for (const Declaration& decl : psShader->asPhases[0].psDecl)
+    {
+        if (decl.eOpcode != OPCODE_DCL_INPUT_PS)
+            continue;
+
+        const Operand& operand = decl.asOperands[0];
+        if (!operand.iPSInOut)
+            continue;
+
+        const ShaderInfo::InOutSignature* signature = NULL;
+        if (!psShader->sInfo.GetInputSignatureFromRegister(operand.ui32RegisterNumber, operand.ui32CompMask, &signature, true))
+            continue;
+
+        const int index = signature->ui32SemanticIndex;
+        if (index > maxInOutRenderTargetIndex)
+            maxInOutRenderTargetIndex = index;
+    }
+
+    if (maxInOutRenderTargetIndex >= 0)
+    {
+        if (maxInOutRenderTargetIndex >= psDependencies->m_NextAvailableGLSLResourceBinding[GLSLCrossDependencyData::BufferType_Texture])
+            psDependencies->m_NextAvailableGLSLResourceBinding[GLSLCrossDependencyData::BufferType_Texture] = maxInOutRenderTargetIndex + 1;
+    }
+}
+
 void HLSLCrossCompilerContext::ClearDependencyData()
 {
     switch (psShader->eShaderType)

src/HLSLCrossCompilerContext.cpp

@@ -1,6 +1,7 @@
 #include "hlslcc.h"
 
 #include <memory>
+#include <sstream>
 #include "internal_includes/HLSLCrossCompilerContext.h"
 #include "internal_includes/toGLSL.h"
 #include "internal_includes/toMetal.h"
@@ -27,6 +28,27 @@
 #define GL_COMPUTE_SHADER 0x91B9
 #endif
 
+static bool CheckConstantBuffersNoDuplicateNames(const std::vector<ConstantBuffer>& buffers, HLSLccReflection& reflectionCallbacks)
+{
+    uint32_t count = buffers.size();
+    for (uint32_t i = 0; i < count; ++i)
+    {
+        const ConstantBuffer& lhs = buffers[i];
+        for (uint32_t j = i + 1; j < count; ++j)
+        {
+            const ConstantBuffer& rhs = buffers[j];
+            if (lhs.name == rhs.name)
+            {
+                std::ostringstream oss;
+                oss << "Duplicate constant buffer declaration: " << lhs.name;
+                reflectionCallbacks.OnDiagnostics(oss.str(), 0, true);
+                return false;
+            }
+        }
+    }
+
+    return true;
+}
 
 HLSLCC_API int HLSLCC_APIENTRY TranslateHLSLFromMem(const char* shader,
     unsigned int flags,
@@ -49,6 +71,10 @@ HLSLCC_API int HLSLCC_APIENTRY TranslateHLSLFromMem(const char* shader,
 
     if (psShader.get())
     {
+        Shader* shader = psShader.get();
+        if (!CheckConstantBuffersNoDuplicateNames(shader->sInfo.psConstantBuffers, reflectionCallbacks))
+            return 0;
+
         HLSLCrossCompilerContext sContext(reflectionCallbacks);
 
         // Add shader precisions from the list
@@ -59,7 +85,11 @@ HLSLCC_API int HLSLCC_APIENTRY TranslateHLSLFromMem(const char* shader,
             flags &= ~HLSLCC_FLAG_COMBINE_TEXTURE_SAMPLERS;
         }
 
-        sContext.psShader = psShader.get();
+#ifdef _DEBUG
+        flags |= HLSLCC_FLAG_INCLUDE_INSTRUCTIONS_COMMENTS;
+#endif
+
+        sContext.psShader = shader;
         sContext.flags = flags;
 
         // If dependencies == NULL, we'll create a dummy object for it so that there's always something there.
@@ -68,6 +98,7 @@ HLSLCC_API int HLSLCC_APIENTRY TranslateHLSLFromMem(const char* shader,
         {
             depPtr.reset(new GLSLCrossDependencyData());
             sContext.psDependencies = depPtr.get();
+            sContext.psDependencies->SetupGLSLResourceBindingSlotsIndices();
         }
         else
             sContext.psDependencies = dependencies;