DxilConv update - bug fixes and pre/post convert hooks (#2760)

* DxilConv update - bug fixes and pre/post convert hooks

* Fix tests

Author: hekota

projects/dxilconv/include/DxilConvPasses/NormalizeDxil.h

@@ -17,11 +17,24 @@ namespace llvm {
   class Function;
   class PassRegistry;
   class FunctionPass;
+  class Function;
+  class DominatorTree;
 
 
   llvm::FunctionPass *createNormalizeDxilPass();
   void initializeNormalizeDxilPassPass(llvm::PassRegistry&);
 
+  class NormalizeDxil {
+  public:
+    NormalizeDxil(Function &F, DominatorTree &DT) : m_function(F), m_dominatorTree(DT) {}
+
+    virtual bool Run();
+
+  protected:
+    Function &m_function;
+    DominatorTree &m_dominatorTree;
+  };
+
   // The legacy pass manager's analysis pass to normalize dxil ir.
   class NormalizeDxilPass : public FunctionPass {
   public:

projects/dxilconv/include/DxilConvPasses/ScopeNestIterator.h

@@ -833,11 +833,11 @@ class ScopeNestIterator
                 // Make sure we are not ending a scope end because that will cause
                 // us to move from the stack again. Indicates some problem with the
                 // state transition.
+                // Allow SwitchEnd for empty case
                 BranchKind Kind = annotation.Get();
                 DXASSERT_LOCALVAR_NOMSG(Kind, Kind != BranchKind::IfEnd &&
                        Kind != BranchKind::LoopBackEdge &&
-                       Kind != BranchKind::LoopExit &&
-                       Kind != BranchKind::SwitchEnd);
+                       Kind != BranchKind::LoopExit);                       
             }
             MoveToBlock(B);
         }

projects/dxilconv/include/Support/DXIncludes.h

@@ -31,5 +31,9 @@
 #include "DxbcSignatures.h"
 #include <d3dcompiler.h>
 #include <wincrypt.h>
+
+#ifndef DECODE_D3D10_SB_TOKENIZED_PROGRAM_TYPE
 #include <d3d12TokenizedProgramFormat.hpp>
+#endif
+
 #include <ShaderBinary/ShaderBinary.h>

projects/dxilconv/lib/DxbcConverter/DxbcConverter.cpp

@@ -224,6 +224,9 @@ void DxbcConverter::ConvertImpl(_In_reads_bytes_(DxbcSize) LPCVOID pDxbc,
     ConvertSignature(*m_pPatchConstantSignature, m_pPR->GetPatchConstOrPrimSignature());
   }
 
+  // 3.5. Callback before conversion
+  PreConvertHook(pByteCode);
+
   // 4. Transform DXBC to DXIL.
   Parser.SetShader(pByteCode);
   ConvertInstructions(Parser);
@@ -235,6 +238,9 @@ void DxbcConverter::ConvertImpl(_In_reads_bytes_(DxbcSize) LPCVOID pDxbc,
   // 6. Cleanup/Optimize DXIL.
   Optimize();
 
+  // 7. Callback after conversion
+  PostConvertHook(pByteCode);
+
   // Serialize DXIL.
   SmallVector<char, 4*1024> DxilBuffer;
   SerializeDxil(DxilBuffer);
@@ -385,6 +391,9 @@ void DxbcConverter::ConvertInDriverImpl(_In_reads_bytes_(8) const UINT32 *pByteC
     ConvertSignature(*m_pPatchConstantSignature, m_pPR->GetPatchConstOrPrimSignature());
   }
 
+  // 3.5. Callback before conversion
+  PreConvertHook(pByteCode);
+
   // 4. Transform DXBC to DXIL.
   Parser.SetShader(pByteCode);
   ConvertInstructions(Parser);
@@ -395,6 +404,9 @@ void DxbcConverter::ConvertInDriverImpl(_In_reads_bytes_(8) const UINT32 *pByteC
   // 6. Cleanup/Optimize DXIL.
   Optimize();
 
+  // 7. Callback after conversion
+  PostConvertHook(pByteCode);
+
   // Serialize DXIL.
   SmallVector<char, 8*1024> DxilBuffer;
   raw_svector_ostream DxilStream(DxilBuffer);
@@ -3653,6 +3665,8 @@ void DxbcConverter::ConvertInstructions(D3D10ShaderBinary::CShaderCodeParser &Pa
       // Resource.
       OperandValue InRes;
       LoadOperand(InRes, Inst, uOpUAV, CMask::MakeXMask(), CompType::getInvalid());
+      // SetHasCounter.
+      SetHasCounter(Inst, uOpUAV);
 
       // Create BufferUpdateCounter call.
       Value *Args[3];
@@ -4509,6 +4523,14 @@ void DxbcConverter::LogConvertResult(bool InDriver, _In_ const LARGE_INTEGER *pQ
   // intentionaly empty - override to report conversion results
 }
 
+HRESULT DxbcConverter::PreConvertHook(const CShaderToken *pByteCode) {
+  return S_OK;
+}
+
+HRESULT DxbcConverter::PostConvertHook(const CShaderToken *pByteCode) {
+  return S_OK;
+}
+
 void DxbcConverter::HandleUnknownInstruction(D3D10ShaderBinary::CInstruction &Inst) {
     DXASSERT_ARGS(false, "OpCode %u is not yet implemented", Inst.OpCode());
 }
@@ -5707,6 +5729,18 @@ Value *DxbcConverter::LoadConstFloat(float& fVal) {
   }
 }
 
+void DxbcConverter::SetHasCounter(D3D10ShaderBinary::CInstruction &Inst, const unsigned uOpUAV) {
+  D3D10ShaderBinary::COperandBase &O = Inst.m_Operands[uOpUAV];
+  DXASSERT_DXBC(O.m_Type == D3D11_SB_OPERAND_TYPE_UNORDERED_ACCESS_VIEW);
+
+  // Retrieve UAV range ID and record.
+  DXASSERT_DXBC(O.m_IndexType[0] == D3D10_SB_OPERAND_INDEX_IMMEDIATE32);
+  unsigned RangeID = O.m_Index[0].m_RegIndex;
+  unsigned RecIdx = m_UAVRangeMap[RangeID];
+  DxilResource &R = m_pPR->GetUAV(RecIdx);
+  R.SetHasCounter(true);
+}
+
 void DxbcConverter::LoadOperand(OperandValue &SrcVal,
                                 D3D10ShaderBinary::CInstruction &Inst,
                                 const unsigned OpIdx,
@@ -6365,6 +6399,7 @@ void DxbcConverter::LoadOperand(OperandValue &SrcVal,
   case D3D11_SB_OPERAND_TYPE_INPUT_JOIN_INSTANCE_ID: {
     Scope &HullScope = m_ScopeStack.FindParentHullLoop();
     Value *pValue = m_pBuilder->CreateLoad(HullScope.pInductionVar);
+    pValue = ApplyOperandModifiers(pValue, O);
 
     for (OperandValueHelper OVH(SrcVal, Mask, O); !OVH.IsDone(); OVH.Advance()) {
       OVH.SetValue(pValue);

projects/dxilconv/lib/DxbcConverter/DxbcConverterImpl.h

@@ -528,6 +528,8 @@ class DxbcConverter : public IDxbcConverter {
 
 
   // Callbacks added to support conversion of custom intrinsics.
+  virtual HRESULT PreConvertHook(const CShaderToken *pByteCode);
+  virtual HRESULT PostConvertHook(const CShaderToken *pByteCode);
   virtual void HandleUnknownInstruction(D3D10ShaderBinary::CInstruction &Inst);
   virtual unsigned GetResourceSlot(D3D10ShaderBinary::CInstruction &Inst);
 
@@ -605,6 +607,7 @@ class DxbcConverter : public IDxbcConverter {
   void CheckDxbcString(const char *pStr, const void *pMaxPtrInclusive);
 
   Value *LoadConstFloat(float& fVal);
+  void SetHasCounter(D3D10ShaderBinary::CInstruction &Inst, const unsigned uOpUAV);
   void LoadOperand(OperandValue &SrcVal, D3D10ShaderBinary::CInstruction &Inst, const unsigned OpIdx, const CMask &Mask, const CompType &ValueType);
   const DxilResource& LoadSRVOperand(OperandValue &SrcVal, D3D10ShaderBinary::CInstruction &Inst, const unsigned OpIdx, const CMask &Mask, const CompType &ValueType);
   const DxilResource& GetSRVFromOperand(D3D10ShaderBinary::CInstruction &Inst, const unsigned OpIdx);

projects/dxilconv/lib/DxilConvPasses/NormalizeDxil.cpp

@@ -143,18 +143,6 @@ bool NormalizeResourceHandle::Run(Function &function, DominatorTree &DT) {
   return candidates.size() > 0;
 }
 
-class NormalizeDxil {
-public:
-  NormalizeDxil(Function &F, DominatorTree &DT) : m_function(F), m_dominatorTree(DT) {}
-
-  bool Run();
-
-private:
-  Function &m_function;
-  DominatorTree &m_dominatorTree;
-};
-
-
 bool NormalizeDxil::Run() {
   return NormalizeResourceHandle().Run(m_function, m_dominatorTree);
 }

projects/dxilconv/test/regression_tests/AppendStructuredBuffer.hlsl

@@ -0,0 +1,27 @@
+// RUN: %fxc /Tps_5_0 %s /Fo %t.fxc
+// RUN: %dxbc2dxil %t.fxc /emit-llvm | %FileCheck %s -check-prefix=DXIL
+
+// DXIL: !{i32 0, %dx.types.i8x28 addrspace(1)* undef, !"U0", i32 0, i32 5, i32 1, i32 12, i1 false, i1 true
+
+struct X {
+  float4 a;
+  float3 b;
+};
+
+AppendStructuredBuffer<X> buf : register(u5);
+
+#ifdef DX12
+#define RS "DescriptorTable(" \
+             "UAV(u5), "\
+             "visibility=SHADER_VISIBILITY_ALL)"
+
+[RootSignature( RS )]
+#endif
+float4 main(float i : A) : SV_TARGET
+{
+  X x = (X)0;
+  x.a = i;
+  x.b = i + 1;
+  buf.Append(x);
+  return x.a;
+}

projects/dxilconv/test/regression_tests/ConsumeStructuredBuffer.hlsl

@@ -0,0 +1,24 @@
+// RUN: %fxc /Tps_5_0 %s /Fo %t.fxc
+// RUN: %dxbc2dxil %t.fxc /emit-llvm | %FileCheck %s -check-prefix=DXIL
+
+// DXIL: !{i32 0, %dx.types.i8x36 addrspace(1)* undef, !"U0", i32 0, i32 5, i32 1, i32 12, i1 false, i1 true
+
+struct X {
+  float4 a;
+  float3 b;
+  float2 c;
+};
+
+ConsumeStructuredBuffer<X> buf : register(u5);
+
+#ifdef DX12
+#define RS "DescriptorTable(" \
+             "UAV(u5), "\
+             "visibility=SHADER_VISIBILITY_ALL)"
+
+[RootSignature( RS )]
+#endif
+float4 main(int i : A) : SV_TARGET
+{
+  return buf.Consume().a;
+}

projects/dxilconv/test/regression_tests/UpdateCounter.hlsl

@@ -0,0 +1,17 @@
+// RUN: %fxc /Tps_5_0 %s /Fo %t.fxc
+// RUN: %dxbc2dxil %t.fxc /emit-llvm | %FileCheck %s -check-prefix=DXIL
+
+// DXIL: !{i32 0, %dx.types.i8x28 addrspace(1)* undef, !"U0", i32 0, i32 1, i32 1, i32 12, i1 false, i1 true
+
+struct Foo {
+  float4 a;
+  float3 b;
+};
+
+
+RWStructuredBuffer<Foo> buf2;
+
+int main() : SV_Target
+{
+  return buf2.IncrementCounter();
+}

projects/dxilconv/test/regression_tests/fork_instanceid_with_modifiers.hlsl

@@ -0,0 +1,51 @@
+// RUN: %fxc /Ths_5_0 %s /Fo %t.dxbc
+// RUN: %dxbc2dxil %t.dxbc /emit-llvm | %FileCheck %s
+
+// RUN: %fxc /Ths_5_1 /DDX12 %s /Fo %t.dxbc
+// RUN: %dxbc2dxil %t.dxbc /emit-llvm | %FileCheck %s
+
+// CHECK: hullloop0:
+// CHECK: %[[InstanceID:.*]] = phi i32
+// CHECK: sub i32 0, %[[InstanceID:.*]]
+
+#ifndef DX12
+#define RS
+#else
+#define RS [RootSignature("CBV(b2)")]
+#endif
+
+struct Vertex
+{
+    float4 pos : SV_POSITION;
+    float4 c : COLOR;
+};
+
+struct HullShaderConstantData
+{
+    float Edges[4] : SV_TessFactor;
+    float Inside[2] : SV_InsideTessFactor;
+};
+
+
+cbuffer Buf0 : register(b2) {
+uint foo;
+}
+
+HullShaderConstantData ConstantFunction( InputPatch<Vertex, 5> In )
+{
+    HullShaderConstantData Out = (HullShaderConstantData)0;
+    for (int i = 0; i<4; ++i) {
+      Out.Edges[i] += In[foo - i].c.w;
+    }    
+    return Out;
+}
+
+RS
+[domain("quad")]
+[partitioning("integer")]
+[outputtopology("point")]
+[outputcontrolpoints(0)]
+[patchconstantfunc("ConstantFunction")]
+void main( InputPatch<Vertex, 5> In, uint i : SV_OutputControlPointID )
+{
+}