Merge branch 'microsoft:main' into issue-6615

Author: tcorringham

docs/ReleaseNotes.md

@@ -38,10 +38,16 @@ line upon naming the release. Refer to previous for appropriate section names.
 
 #### Bug Fixes
 
-- Fixed non-deterministic DXIL/PDB output when compiling shaders with resource arrays, debug info, and SM 6.6+. [#8171](https://github.com/microsoft/DirectXShaderCompiler/issues/8171)
+- Fixed non-deterministic DXIL/PDB output when compiling shaders with resource
+  arrays, debug info, and SM 6.6+.
+  [#8171](https://github.com/microsoft/DirectXShaderCompiler/issues/8171)
 - Fixed mesh shader semantics that were incorrectly case sensitive.
+- User-defined conversion operators (e.g., `operator float4()`) now produce an
+  error instead of being silently ignored.
+  [#5103](https://github.com/microsoft/DirectXShaderCompiler/pull/8206)
 - DXIL validation: added validation for `CreateHandleFromBinding`.
-- DXIL validation now rejects non-standard integer bit widths (e.g. `i25`) in instructions.
+- DXIL validation now rejects non-standard integer bit widths (e.g. `i25`) in
+  instructions.
 
 #### Other Changes
 

external/SPIRV-Headers

@@ -28,6 +28,7 @@ ModulePass *createDxilShaderAccessTrackingPass();
 ModulePass *createDxilPIXAddTidToAmplificationShaderPayloadPass();
 ModulePass *createDxilPIXDXRInvocationsLogPass();
 ModulePass *createDxilNonUniformResourceIndexInstrumentationPass();
+ModulePass *createDxilDebugBreakInstrumentationPass();
 
 void initializeDxilAddPixelHitInstrumentationPass(llvm::PassRegistry &);
 void initializeDxilDbgValueToDbgDeclarePass(llvm::PassRegistry &);
@@ -44,5 +45,6 @@ void initializeDxilPIXAddTidToAmplificationShaderPayloadPass(
 void initializeDxilPIXDXRInvocationsLogPass(llvm::PassRegistry &);
 void initializeDxilNonUniformResourceIndexInstrumentationPass(
     llvm::PassRegistry &);
+void initializeDxilDebugBreakInstrumentationPass(llvm::PassRegistry &);
 
 } // namespace llvm

external/SPIRV-Tools

@@ -47,7 +47,8 @@
 #include "dxc/Test/TestConfig.h"
 #endif
 
-using namespace std;
+using std::max;
+using std::min;
 
 #ifndef HLSLDATAFILEPARAM
 #define HLSLDATAFILEPARAM L"HlslDataDir"
@@ -121,12 +122,12 @@ static constexpr wchar_t wideWhitespaceChars[] = L" \t\r\n";
 
 inline std::string strltrim(const std::string &value) {
   size_t first = value.find_first_not_of(whitespaceChars);
-  return first == string::npos ? value : value.substr(first);
+  return first == std::string::npos ? value : value.substr(first);
 }
 
 inline std::string strrtrim(const std::string &value) {
   size_t last = value.find_last_not_of(whitespaceChars);
-  return last == string::npos ? value : value.substr(0, last + 1);
+  return last == std::string::npos ? value : value.substr(0, last + 1);
 }
 
 inline std::string strtrim(const std::string &value) {

include/dxc/DxilPIXPasses/DxilPIXPasses.h

@@ -140,11 +140,16 @@ enum LEGAL_INTRINSIC_COMPTYPES {
 
 #ifdef ENABLE_SPIRV_CODEGEN
   LICOMPTYPE_VK_BUFFER_POINTER = 56,
-  LICOMPTYPE_VK_SAMPLED_TEXTURE2D = 57,
-  LICOMPTYPE_VK_SAMPLED_TEXTURE2D_ARRAY = 58,
-  LICOMPTYPE_VK_SAMPLED_TEXTURE2DMS = 59,
-  LICOMPTYPE_VK_SAMPLED_TEXTURE2DMS_ARRAY = 60,
-  LICOMPTYPE_COUNT = 61
+  LICOMPTYPE_VK_SAMPLED_TEXTURE1D = 57,
+  LICOMPTYPE_VK_SAMPLED_TEXTURE1D_ARRAY = 58,
+  LICOMPTYPE_VK_SAMPLED_TEXTURE2D = 59,
+  LICOMPTYPE_VK_SAMPLED_TEXTURE2D_ARRAY = 60,
+  LICOMPTYPE_VK_SAMPLED_TEXTURE2DMS = 61,
+  LICOMPTYPE_VK_SAMPLED_TEXTURE2DMS_ARRAY = 62,
+  LICOMPTYPE_VK_SAMPLED_TEXTURE3D = 63,
+  LICOMPTYPE_VK_SAMPLED_TEXTURECUBE = 64,
+  LICOMPTYPE_VK_SAMPLED_TEXTURECUBE_ARRAY = 65,
+  LICOMPTYPE_COUNT = 66
 #else
   LICOMPTYPE_COUNT = 56
 #endif

include/dxc/Test/HlslTestUtils.h

@@ -2838,8 +2838,8 @@ static const OP::OpCodeProperty ExperimentalOps_OpCodeProps[] = {
      "linAlgFillMatrix",
      Attribute::None,
      2,
-     {{0x200}, {0x63}},
-     {{0x0}, {0x0}}}, // Overloads: o,hfwi
+     {{0x200}, {0xe7}},
+     {{0x0}, {0x0}}}, // Overloads: o,hfdwil
     {OC::LinAlgCopyConvertMatrix,
      "LinAlgCopyConvertMatrix",
      OCC::LinAlgCopyConvertMatrix,
@@ -2862,8 +2862,8 @@ static const OP::OpCodeProperty ExperimentalOps_OpCodeProps[] = {
      "linAlgMatrixLoadFromMemory",
      Attribute::None,
      2,
-     {{0x200}, {0x63}},
-     {{0x0}, {0x0}}}, // Overloads: o,hfwi
+     {{0x200}, {0xe7}},
+     {{0x0}, {0x0}}}, // Overloads: o,hfdwil
     {OC::LinAlgMatrixLength,
      "LinAlgMatrixLength",
      OCC::LinAlgMatrixLength,
@@ -2886,16 +2886,16 @@ static const OP::OpCodeProperty ExperimentalOps_OpCodeProps[] = {
      "linAlgMatrixGetElement",
      Attribute::None,
      2,
-     {{0x63}, {0x200}},
-     {{0x0}, {0x0}}}, // Overloads: hfwi,o
+     {{0xe7}, {0x200}},
+     {{0x0}, {0x0}}}, // Overloads: hfdwil,o
     {OC::LinAlgMatrixSetElement,
      "LinAlgMatrixSetElement",
      OCC::LinAlgMatrixSetElement,
      "linAlgMatrixSetElement",
      Attribute::None,
      3,
-     {{0x200}, {0x200}, {0x63}},
-     {{0x0}, {0x0}, {0x0}}}, // Overloads: o,o,hfwi
+     {{0x200}, {0x200}, {0xe7}},
+     {{0x0}, {0x0}, {0x0}}}, // Overloads: o,o,hfdwil
     {OC::LinAlgMatrixStoreToDescriptor,
      "LinAlgMatrixStoreToDescriptor",
      OCC::LinAlgMatrixStoreToDescriptor,
@@ -2910,8 +2910,8 @@ static const OP::OpCodeProperty ExperimentalOps_OpCodeProps[] = {
      "linAlgMatrixStoreToMemory",
      Attribute::None,
      2,
-     {{0x200}, {0x63}},
-     {{0x0}, {0x0}}}, // Overloads: o,hfwi
+     {{0x200}, {0xe7}},
+     {{0x0}, {0x0}}}, // Overloads: o,hfdwil
     {OC::LinAlgMatrixQueryAccumulatorLayout,
      "LinAlgMatrixQueryAccumulatorLayout",
      OCC::LinAlgMatrixQueryAccumulatorLayout,
@@ -2943,15 +2943,15 @@ static const OP::OpCodeProperty ExperimentalOps_OpCodeProps[] = {
      Attribute::None,
      3,
      {{0x400}, {0x200}, {0x400}},
-     {{0x63}, {0x0}, {0x63}}}, // Overloads: <hfwi,o,<hfwi
+     {{0xe7}, {0x0}, {0xe7}}}, // Overloads: <hfdwil,o,<hfdwil
     {OC::LinAlgMatVecMulAdd,
      "LinAlgMatVecMulAdd",
      OCC::LinAlgMatVecMulAdd,
      "linAlgMatVecMulAdd",
      Attribute::None,
      4,
      {{0x400}, {0x200}, {0x400}, {0x400}},
-     {{0x63}, {0x0}, {0x63}, {0x63}}}, // Overloads: <hfwi,o,<hfwi,<hfwi
+     {{0xe7}, {0x0}, {0xe7}, {0xe7}}}, // Overloads: <hfdwil,o,<hfdwil,<hfdwil
     {OC::LinAlgMatrixAccumulateToDescriptor,
      "LinAlgMatrixAccumulateToDescriptor",
      OCC::LinAlgMatrixAccumulateToDescriptor,
@@ -2966,24 +2966,24 @@ static const OP::OpCodeProperty ExperimentalOps_OpCodeProps[] = {
      "linAlgMatrixAccumulateToMemory",
      Attribute::None,
      2,
-     {{0x200}, {0x63}},
-     {{0x0}, {0x0}}}, // Overloads: o,hfwi
+     {{0x200}, {0xe7}},
+     {{0x0}, {0x0}}}, // Overloads: o,hfdwil
     {OC::LinAlgMatrixOuterProduct,
      "LinAlgMatrixOuterProduct",
      OCC::LinAlgMatrixOuterProduct,
      "linAlgMatrixOuterProduct",
      Attribute::None,
      3,
      {{0x200}, {0x400}, {0x400}},
-     {{0x0}, {0x63}, {0x63}}}, // Overloads: o,<hfwi,<hfwi
+     {{0x0}, {0xe7}, {0xe7}}}, // Overloads: o,<hfdwil,<hfdwil
     {OC::LinAlgConvert,
      "LinAlgConvert",
      OCC::LinAlgConvert,
      "linAlgConvert",
      Attribute::None,
      2,
      {{0x400}, {0x400}},
-     {{0x63}, {0x63}}}, // Overloads: <hfwi,<hfwi
+     {{0xe7}, {0xe7}}}, // Overloads: <hfdwil,<hfdwil
 
     {OC::ReservedE0,
      "ReservedE0",

include/dxc/dxcapi.internal.h

@@ -21,6 +21,7 @@ add_llvm_library(LLVMDxilPIXPasses
   DxilPIXAddTidToAmplificationShaderPayload.cpp
   DxilPIXDXRInvocationsLog.cpp
   DxilNonUniformResourceIndexInstrumentation.cpp
+  DxilDebugBreakInstrumentation.cpp
 
   ADDITIONAL_HEADER_DIRS
   ${LLVM_MAIN_INCLUDE_DIR}/llvm/IR

lib/DXIL/DxilOperations.cpp

@@ -0,0 +1,150 @@
+///////////////////////////////////////////////////////////////////////////////
+//                                                                           //
+// DxilDebugBreakInstrumentation.cpp                                         //
+// Copyright (C) Microsoft Corporation. All rights reserved.                 //
+// This file is distributed under the University of Illinois Open Source     //
+// License. See LICENSE.TXT for details.                                     //
+//                                                                           //
+// Provides a pass to instrument DebugBreak() calls for PIX. Each           //
+// DebugBreak call is replaced with a UAV bit-write so PIX can detect       //
+// which DebugBreak locations were hit without halting the GPU.              //
+//                                                                           //
+///////////////////////////////////////////////////////////////////////////////
+
+#include "PixPassHelpers.h"
+#include "dxc/DXIL/DxilOperations.h"
+#include "dxc/DxilPIXPasses/DxilPIXPasses.h"
+#include "dxc/DxilPIXPasses/DxilPIXVirtualRegisters.h"
+#include "dxc/Support/Global.h"
+#include "llvm/IR/Module.h"
+#include "llvm/Support/FormattedStream.h"
+
+using namespace llvm;
+using namespace hlsl;
+
+class DxilDebugBreakInstrumentation : public ModulePass {
+
+public:
+  static char ID; // Pass identification, replacement for typeid
+  explicit DxilDebugBreakInstrumentation() : ModulePass(ID) {}
+  StringRef getPassName() const override {
+    return "DXIL DebugBreak Instrumentation";
+  }
+  bool runOnModule(Module &M) override;
+};
+
+bool DxilDebugBreakInstrumentation::runOnModule(Module &M) {
+  DxilModule &DM = M.GetOrCreateDxilModule();
+  LLVMContext &Ctx = M.getContext();
+  OP *HlslOP = DM.GetOP();
+
+  hlsl::DxilResource *PixUAVResource = nullptr;
+
+  UndefValue *UndefArg = UndefValue::get(Type::getInt32Ty(Ctx));
+
+  // Atomic operation to use for writing to the result UAV resource
+  Function *AtomicOpFunc =
+      HlslOP->GetOpFunc(OP::OpCode::AtomicBinOp, Type::getInt32Ty(Ctx));
+  Constant *AtomicBinOpcode =
+      HlslOP->GetU32Const((uint32_t)OP::OpCode::AtomicBinOp);
+  Constant *AtomicOr = HlslOP->GetU32Const((uint32_t)DXIL::AtomicBinOpCode::Or);
+
+  std::map<Function *, CallInst *> FunctionToUAVHandle;
+
+  // Collect all DebugBreak calls first, then modify.
+  // This avoids invalidating iterators during modification.
+  std::vector<CallInst *> DebugBreakCalls;
+
+  Function *DebugBreakFunc =
+      HlslOP->GetOpFunc(OP::OpCode::DebugBreak, Type::getVoidTy(Ctx));
+  for (const Use &U : DebugBreakFunc->uses()) {
+    DebugBreakCalls.push_back(cast<CallInst>(U.getUser()));
+  }
+
+  for (CallInst *CI : DebugBreakCalls) {
+    if (!PixUAVResource)
+      PixUAVResource =
+          PIXPassHelpers::CreateGlobalUAVResource(DM, 0, "PixUAVResource");
+
+    Function *F = CI->getParent()->getParent();
+
+    CallInst *PixUAVHandle = nullptr;
+    const auto FunctionToUAVHandleIter = FunctionToUAVHandle.lower_bound(F);
+
+    if ((FunctionToUAVHandleIter != FunctionToUAVHandle.end()) &&
+        (FunctionToUAVHandleIter->first == F)) {
+      PixUAVHandle = FunctionToUAVHandleIter->second;
+    } else {
+      IRBuilder<> Builder(F->getEntryBlock().getFirstInsertionPt());
+
+      PixUAVHandle = PIXPassHelpers::CreateHandleForResource(
+          DM, Builder, PixUAVResource, "PixUAVHandle");
+
+      FunctionToUAVHandle.insert(FunctionToUAVHandleIter, {F, PixUAVHandle});
+    }
+
+    IRBuilder<> Builder(CI);
+
+    uint32_t InstructionNumber = 0;
+    if (!pix_dxil::PixDxilInstNum::FromInst(CI, &InstructionNumber)) {
+      DXASSERT(false, "Failed to extract PIX instruction number metadata from "
+                      "DebugBreak call");
+    }
+
+    // The output UAV is treated as a bit array where each bit corresponds
+    // to an instruction number.
+    const uint32_t InstructionNumByteOffset =
+        (InstructionNumber / 32u) * sizeof(uint32_t);
+    const uint32_t InstructionNumBitPosition = (InstructionNumber % 32u);
+    const uint32_t InstructionNumBitMask = 1u << InstructionNumBitPosition;
+
+    Constant *UAVByteOffsetArg = HlslOP->GetU32Const(InstructionNumByteOffset);
+    Constant *BitMaskArg = HlslOP->GetU32Const(InstructionNumBitMask);
+
+    // Write a 1 bit at the position corresponding to this DebugBreak's
+    // instruction number, indicating it was hit.
+    Builder.CreateCall(
+        AtomicOpFunc,
+        {
+            AtomicBinOpcode,  // i32, ; opcode
+            PixUAVHandle,     // %dx.types.Handle, ; resource handle
+            AtomicOr,         // i32, ; binary operation code
+            UAVByteOffsetArg, // i32, ; coordinate c0: byte offset
+            UndefArg,         // i32, ; coordinate c1 (unused)
+            UndefArg,         // i32, ; coordinate c2 (unused)
+            BitMaskArg        // i32);  value
+        },
+        "DebugBreakBitSet");
+
+    // Remove the original DebugBreak call to prevent GPU halt
+    CI->eraseFromParent();
+  }
+
+  // Clean up the now-unused declaration. Not strictly required for
+  // correctness, but keeps the module free of dead references.
+  if (DebugBreakFunc->use_empty())
+    DebugBreakFunc->eraseFromParent();
+
+  const bool modified = (PixUAVResource != nullptr);
+
+  if (modified) {
+    DM.ReEmitDxilResources();
+
+    if (OSOverride != nullptr) {
+      formatted_raw_ostream FOS(*OSOverride);
+      FOS << "\nFoundDebugBreak\n";
+    }
+  }
+
+  return modified;
+}
+
+char DxilDebugBreakInstrumentation::ID = 0;
+
+ModulePass *llvm::createDxilDebugBreakInstrumentationPass() {
+  return new DxilDebugBreakInstrumentation();
+}
+
+INITIALIZE_PASS(DxilDebugBreakInstrumentation,
+                "hlsl-dxil-debugbreak-instrumentation",
+                "HLSL DXIL DebugBreak instrumentation for PIX", false, false)

lib/DxilPIXPasses/CMakeLists.txt

@@ -7551,6 +7551,8 @@ def err_hlsl_matrix_member_zero_in_one_based: Error<
   "the digit '0' is used in '%0', but the syntax is for one-based rows and columns">;
 def err_hlsl_overloading_operator_disallowed: Error<
   "overloading %select{|non-member }1%0 is not allowed">;
+def err_hlsl_unsupported_conversion_operator: Error<
+  "conversion operator overloading is not allowed">;
 def err_hlsl_vector_member_bad_format: Error<
   "invalid format for vector swizzle '%0'">;
 def err_hlsl_vector_member_empty: Error<