Update 1.10.2605 preview release to main

AIToolPolicy.md

@@ -0,0 +1,57 @@
+# AI Tool Use Policy
+
+This policy aims to be compatible with the [LLVM AI Tool Use
+Policy](https://llvm.org/docs/AIToolPolicy.html) so that people contributing to
+both projects have a similar policy to work with.
+
+Contributors to DirectXShaderCompiler can use whatever tools they would like to
+craft their contributions, but there must be a **human in the loop. Contributors
+must read and review all LLM-generated code or text before they ask other
+project members to review it.** The contributor is always the author and is
+fully accountable for their contributions. Contributors should be sufficiently
+confident that the contribution is high enough quality that asking for a review
+is a good use of scarce maintainer time, and they should be **able to answer
+questions about their work during review.**
+
+We expect that new contributors will be less confident in their contributions,
+and our guidance to them is to **start with small contributions** that they can
+fully understand to build confidence. We aspire to be a welcoming community that
+helps new contributors grow their expertise, but learning involves taking small
+steps, getting feedback, and iterating. Passing maintainer feedback to an LLM
+doesn't help anyone grow and does not sustain our community.
+
+Contributors are expected to **be transparent and label contributions that
+contain substantial amounts of tool-generated content.** Our policy on labelling
+is intended to facilitate reviews, and not track which parts of the project are
+generated. Contributors should note tool usage in their pull request
+description, commit message, or wherever authorship is normally indicated for
+the work. For instance, use a commit message trailer like Assisted-by: Copilot.
+This transparency helps the community develop best practices and understand the
+role of these new tools.
+
+## Copilot Code Reviews
+
+Copilot code reviews are allowed.  It's TBD whether we will enable these by
+default for all PRs - but feel free to request a review from Copilot.
+
+## Cloud Agents
+
+The cloud-based version of GitHub Copilot is a great way to have multiple agents
+work simultaneously and autonomously on issues.  However, we require that these
+run in a fork of the repo rather than in the main repo itself.  Then, once the
+change has been crafted such that it is ready for others to review, a PR can be
+opened to merge it into upstream. Rationale:
+
+* Everyone should be working in a fork rather than creating branches in the main
+  repo, agents are no different. 
+* We shouldn't be spamming people watching the main repo with the agent's work.
+* As you're responsible for the work Copilot is doing, the PR into upstream
+  should come from you, not from Copilot. 
+
+Note that cloud agents are only able to build and test on Linux, and this
+affects the sort of work an agent can do.
+
+## Local Agents
+
+CLI, or editor-hosted agents, run on your own machine, so there is less concern
+about the activity of these agents impacting others.

azure-pipelines.yml

@@ -27,16 +27,21 @@ stages:
       matrix:
         VS2022_Release:
          configuration: Release
+         spirvBuildFlag: -spirvtest
         VS2022_Debug:
          configuration: Debug
+         spirvBuildFlag: -spirvtest
+        VS2022_Release_NoSPIRV:
+         configuration: Release
+         spirvBuildFlag: ''
 
     steps:
     - checkout: self
       clean: true
       submodules: true
     - script: |
         call utils\hct\hctstart.cmd %HLSL_SRC_DIR% %HLSL_BLD_DIR%
-        call utils\hct\hctbuild.cmd -vs2022 -$(platform) -$(configuration) -show-cmake-log -spirvtest -warp-nuget-version 1.0.16.1
+        call utils\hct\hctbuild.cmd -vs2022 -$(platform) -$(configuration) -show-cmake-log $(spirvBuildFlag) -warp-nuget-version 1.0.16.1
       displayName: 'Building'
     - script: |
         call utils\hct\hctstart.cmd %HLSL_SRC_DIR% %HLSL_BLD_DIR%

docs/DXIL.rst

@@ -3096,8 +3096,8 @@ ID         Name                                     Description
 2147483676 LinAlgMatrixAccumulateToMemory           accumulates a matrix to groupshared memory
 2147483677 LinAlgMatrixOuterProduct                 Outer products an M sized vector and a N sized vector producing an MxN matrix
 2147483678 LinAlgConvert                            Convert vector components from one interpretation to another
-2147483679 ReservedE0                               reserved
-2147483680 ReservedE1                               reserved
+2147483679 LinAlgVectorAccumulateToDescriptor       Accumulates given vector to the buffer at the given offset
+2147483680 ReservedE0                               reserved
 2147483681 DebugBreak                               triggers a breakpoint if a debugger is attached
 2147483682 IsDebuggerPresent                        returns true if a debugger is attached
 ========== ======================================== ===================================================================================================================

docs/ReleaseNotes.md

@@ -17,6 +17,23 @@ The included licenses apply to the following files:
 
 ## Changelog
 
+### Version 1.10.2605.1 (preview)
+
+#### Experimental Shader Model 6.10
+- Added VectorAccumlate operaton to LinAlg Matrix API [#8448](https://github.com/microsoft/DirectXShaderCompiler/pull/8448)
+
+#### Experimental Shader Model 6.10 Bug Fixes
+- Fixed validator rejecting LinAlgMatrix type in DXIL [#8441](https://github.com/microsoft/DirectXShaderCompiler/pull/8441)
+- Fixed float trunc and coord calc errors in ExecTests [#8420](https://github.com/microsoft/DirectXShaderCompiler/pull/8420)
+- Convert Bias Vector to match the output type [#8394](https://github.com/microsoft/DirectXShaderCompiler/pull/8394)
+
+#### Bug Fixes
+- Fixed build break on certain platforms [#8307](https://github.com/microsoft/DirectXShaderCompiler/pull/8307)
+- SPIR-V: Fix compiler error for certain pointer casts [#7891](https://github.com/microsoft/DirectXShaderCompiler/issues/7891)
+- Raise a compliation error when invalid `volatile` keyword is used [8397](https://github.com/microsoft/DirectXShaderCompiler/pull/8397)
+- Fixed codegen that emitted illigal-width integerse [#8444](https://github.com/microsoft/DirectXShaderCompiler/pull/8444)
+- Fixed crash when using `-fcgl` when container has a resource arg function [#8442](https://github.com/microsoft/DirectXShaderCompiler/pull/8442)
+
 ### Version 1.10.2605 (preview)
 
 #### Experimental Shader Model 6.10
@@ -75,10 +92,13 @@ The included licenses apply to the following files:
   default, with `/Fi` to override the output filename. The old FXC-style `/P
    <filename>` positional syntax has been renamed to `/Po`.
   [#4611](https://github.com/microsoft/DirectXShaderCompiler/issues/4611).
+- SPIR-V: Support `vk::SampledTexture` types (GLSL's `samplerND` equivalent)
+  [#7979](https://github.com/microsoft/DirectXShaderCompiler/issues/7979). With
+  this type, users no longer need to define both Sampler and Texture resources
+  with the same binding number.
 - Added support for -Fre for Metal
   [#8159](https://github.com/microsoft/DirectXShaderCompiler/pull/8159)
 
-
 ### Version 1.9.2602
 
 #### Shader Model 6.9 Release

include/dxc/DXIL/DxilConstants.h

@@ -533,8 +533,7 @@ static const OpCodeTableID TableID = OpCodeTableID::ExperimentalOps;
 // Enumeration for ExperimentalOps DXIL operations
 enum class OpCode : unsigned {
   //
-  ReservedE0 = 31, // reserved
-  ReservedE1 = 32, // reserved
+  ReservedE0 = 32, // reserved
 
   // Debugging
   DebugBreak = 33,        // triggers a breakpoint if a debugger is attached
@@ -597,6 +596,8 @@ enum class OpCode : unsigned {
   LinAlgMatrixStoreToDescriptor =
       20,                         // stores a matrix to a RWByteAddressBuffer
   LinAlgMatrixStoreToMemory = 21, // stores a matrix to groupshared memory
+  LinAlgVectorAccumulateToDescriptor =
+      31, // Accumulates given vector to the buffer at the given offset
 
   // No-op
   ExperimentalNop = 0, // nop does nothing
@@ -1355,10 +1356,13 @@ enum class OpCode : unsigned {
   // LinAlgConvert = 0x8000001E, 2147483678U, -2147483618
   EXP_OPCODE(ExperimentalOps, LinAlgConvert), // Convert vector components from
                                               // one interpretation to another
-  // ReservedE0 = 0x8000001F, 2147483679U, -2147483617
+  // LinAlgVectorAccumulateToDescriptor = 0x8000001F, 2147483679U, -2147483617
+  EXP_OPCODE(
+      ExperimentalOps,
+      LinAlgVectorAccumulateToDescriptor), // Accumulates given vector to the
+                                           // buffer at the given offset
+  // ReservedE0 = 0x80000020, 2147483680U, -2147483616
   EXP_OPCODE(ExperimentalOps, ReservedE0), // reserved
-  // ReservedE1 = 0x80000020, 2147483680U, -2147483616
-  EXP_OPCODE(ExperimentalOps, ReservedE1), // reserved
   // DebugBreak = 0x80000021, 2147483681U, -2147483615
   EXP_OPCODE(ExperimentalOps,
              DebugBreak), // triggers a breakpoint if a debugger is attached
@@ -1544,6 +1548,7 @@ enum class OpCodeClass : unsigned {
   LinAlgMatrixSetElement,
   LinAlgMatrixStoreToDescriptor,
   LinAlgMatrixStoreToMemory,
+  LinAlgVectorAccumulateToDescriptor,
 
   // Mesh shader instructions
   EmitIndices,
@@ -1730,7 +1735,7 @@ enum class OpCodeClass : unsigned {
   NodeOutputIsValid,
   OutputComplete,
 
-  NumOpClasses = 222, // exclusive last value of enumeration
+  NumOpClasses = 223, // exclusive last value of enumeration
 };
 // OPCODECLASS-ENUM:END
 

include/dxc/DXIL/DxilInstructions.h

@@ -10960,6 +10960,43 @@ struct DxilInst_LinAlgConvert {
   void set_outputInterpretation(llvm::Value *val) { Instr->setOperand(3, val); }
 };
 
+/// This instruction Accumulates given vector to the buffer at the given offset
+struct DxilInst_LinAlgVectorAccumulateToDescriptor {
+  llvm::Instruction *Instr;
+  // Construction and identification
+  DxilInst_LinAlgVectorAccumulateToDescriptor(llvm::Instruction *pInstr)
+      : Instr(pInstr) {}
+  operator bool() const {
+    return hlsl::OP::IsDxilOpFuncCallInst(
+        Instr, hlsl::OP::OpCode::LinAlgVectorAccumulateToDescriptor);
+  }
+  // Validation support
+  bool isAllowed() const { return true; }
+  bool isArgumentListValid() const {
+    if (5 != llvm::dyn_cast<llvm::CallInst>(Instr)->getNumArgOperands())
+      return false;
+    return true;
+  }
+  // Metadata
+  bool requiresUniformInputs() const { return false; }
+  // Operand indexes
+  enum OperandIdx {
+    arg_vector = 1,
+    arg_handle = 2,
+    arg_offset = 3,
+    arg_align = 4,
+  };
+  // Accessors
+  llvm::Value *get_vector() const { return Instr->getOperand(1); }
+  void set_vector(llvm::Value *val) { Instr->setOperand(1, val); }
+  llvm::Value *get_handle() const { return Instr->getOperand(2); }
+  void set_handle(llvm::Value *val) { Instr->setOperand(2, val); }
+  llvm::Value *get_offset() const { return Instr->getOperand(3); }
+  void set_offset(llvm::Value *val) { Instr->setOperand(3, val); }
+  llvm::Value *get_align() const { return Instr->getOperand(4); }
+  void set_align(llvm::Value *val) { Instr->setOperand(4, val); }
+};
+
 /// This instruction triggers a breakpoint if a debugger is attached
 struct DxilInst_DebugBreak {
   llvm::Instruction *Instr;

include/dxc/DXIL/DxilResourceProperties.h

@@ -16,6 +16,7 @@
 namespace llvm {
 class Constant;
 class Type;
+class Module;
 } // namespace llvm
 
 namespace hlsl {
@@ -89,6 +90,7 @@ struct DxilInst_AnnotateHandle;
 namespace resource_helper {
 llvm::Constant *getAsConstant(const DxilResourceProperties &, llvm::Type *Ty,
                               const ShaderModel &);
+llvm::Type *GetResourcePropertiesType(llvm::Module &M);
 DxilResourceProperties loadPropsFromConstant(const llvm::Constant &C);
 DxilResourceProperties
 loadPropsFromAnnotateHandle(DxilInst_AnnotateHandle &annotateHandle,

include/dxc/HlslIntrinsicOp.h

@@ -132,6 +132,7 @@ enum class IntrinsicOp {
   IOP___builtin_LinAlg_MatrixStoreToMemory = 410,
   IOP___builtin_LinAlg_MatrixVectorMultiply = 418,
   IOP___builtin_LinAlg_MatrixVectorMultiplyAdd = 419,
+  IOP___builtin_LinAlg_VectorAccumulateToDescriptor = 423,
   IOP_abort = 102,
   IOP_abs = 103,
   IOP_acos = 104,
@@ -429,7 +430,7 @@ enum class IntrinsicOp {
   IOP_usign = 355,
   MOP_InterlockedUMax = 356,
   MOP_InterlockedUMin = 357,
-  Num_Intrinsics = 423,
+  Num_Intrinsics = 424,
 };
 inline bool HasUnsignedIntrinsicOpcode(IntrinsicOp opcode) {
   switch (opcode) {

include/llvm/ADT/StringRef.h

@@ -571,9 +571,12 @@ namespace llvm {
 }
 
 // HLSL Change Starts
-// StringRef provides an operator string; that trips up the std::pair noexcept specification,
-// which (a) enables the moves constructor (because conversion is allowed), but (b)
-// misclassifies the the construction as nothrow.
+// StringRef provides an operator string; that trips up the std::pair noexcept
+// specification, which (a) enables the moves constructor (because conversion is
+// allowed), but (b) misclassifies the the construction as nothrow. Newer libc++
+// releases reject user specializations of this trait outright, and also compute
+// the trait correctly without help.
+#if !defined(_LIBCPP_VERSION)
 namespace std {
   template<>
   struct is_nothrow_constructible <std::string, llvm::StringRef>
@@ -588,6 +591,7 @@ namespace std {
     : std::false_type {
   };
 }
+#endif
 // HLSL Change Ends
 
 #endif

lib/DXIL/DxilMetadataHelper.cpp

@@ -1345,8 +1345,7 @@ Metadata *DxilMDHelper::EmitDxilFieldAnnotation(const DxilFieldAnnotation &FA) {
     MDVals.emplace_back(Uint32ToConstMD(kDxilFieldAnnotationResPropTag));
     MDVals.emplace_back(ValueAsMetadata::get(resource_helper::getAsConstant(
         FA.GetResourceProperties(),
-        m_pModule->GetDxilModule().GetOP()->GetResourcePropertiesType(),
-        *m_pSM)));
+        resource_helper::GetResourcePropertiesType(*m_pModule), *m_pSM)));
   }
   if (DXIL::CompareVersions(m_MinValMajor, m_MinValMinor, 1, 7) >= 0) {
     if (FA.HasBitFields()) {

lib/DXIL/DxilOperations.cpp

@@ -2984,6 +2984,14 @@ static const OP::OpCodeProperty ExperimentalOps_OpCodeProps[] = {
      2,
      {{0x400}, {0x400}},
      {{0xe7}, {0xe7}}}, // Overloads: <hfdwil,<hfdwil
+    {OC::LinAlgVectorAccumulateToDescriptor,
+     "LinAlgVectorAccumulateToDescriptor",
+     OCC::LinAlgVectorAccumulateToDescriptor,
+     "linAlgVectorAccumulateToDescriptor",
+     Attribute::None,
+     1,
+     {{0x400}},
+     {{0xe7}}}, // Overloads: <hfdwil
 
     {OC::ReservedE0,
      "ReservedE0",
@@ -2993,14 +3001,6 @@ static const OP::OpCodeProperty ExperimentalOps_OpCodeProps[] = {
      0,
      {},
      {}}, // Overloads: v
-    {OC::ReservedE1,
-     "ReservedE1",
-     OCC::Reserved,
-     "reserved",
-     Attribute::None,
-     0,
-     {},
-     {}}, // Overloads: v
 
     // Debugging
     {OC::DebugBreak,
@@ -3956,11 +3956,12 @@ void OP::GetMinShaderModelAndMask(OpCode C, bool bWithTranslation,
   // LinAlgMatVecMulAdd=2147483674,
   // LinAlgMatrixAccumulateToDescriptor=2147483675,
   // LinAlgMatrixOuterProduct=2147483677, LinAlgConvert=2147483678,
-  // DebugBreak=2147483681, IsDebuggerPresent=2147483682
+  // LinAlgVectorAccumulateToDescriptor=2147483679, DebugBreak=2147483681,
+  // IsDebuggerPresent=2147483682
   if (op == 2147483648 || (2147483652 <= op && op <= 2147483653) ||
       (2147483656 <= op && op <= 2147483657) || op == 2147483662 ||
       op == 2147483670 || (2147483673 <= op && op <= 2147483675) ||
-      (2147483677 <= op && op <= 2147483678) ||
+      (2147483677 <= op && op <= 2147483679) ||
       (2147483681 <= op && op <= 2147483682)) {
     major = 6;
     minor = 10;
@@ -4118,9 +4119,8 @@ OP::OP(LLVMContext &Ctx, Module *pModule)
                                             "dx.types.NodeHandle", pModule);
   m_pNodeRecordHandleType = GetOrCreateStructType(
       m_Ctx, Type::getInt8PtrTy(m_Ctx), "dx.types.NodeRecordHandle", pModule);
-  m_pResourcePropertiesType = GetOrCreateStructType(
-      m_Ctx, {Type::getInt32Ty(m_Ctx), Type::getInt32Ty(m_Ctx)},
-      "dx.types.ResourceProperties", pModule);
+  m_pResourcePropertiesType =
+      hlsl::resource_helper::GetResourcePropertiesType(*pModule);
   m_pNodePropertiesType = GetOrCreateStructType(
       m_Ctx, {Type::getInt32Ty(m_Ctx), Type::getInt32Ty(m_Ctx)},
       "dx.types.NodeInfo", pModule);
@@ -6683,13 +6683,17 @@ Function *OP::GetOpFunc(OpCode opCode, Type *pOverloadType) {
     A(pI32);
     A(pI32);
     break;
-
-    //
-  case OpCode::ReservedE0:
+  case OpCode::LinAlgVectorAccumulateToDescriptor:
     A(pV);
     A(pI32);
+    A(pETy);
+    A(pRes);
+    A(pI32);
+    A(pI32);
     break;
-  case OpCode::ReservedE1:
+
+    //
+  case OpCode::ReservedE0:
     A(pV);
     A(pI32);
     break;
@@ -6882,6 +6886,7 @@ llvm::Type *OP::GetOverloadType(OpCode opCode, llvm::Function *F) {
   case OpCode::LinAlgMatrixGetCoordinate:
   case OpCode::LinAlgMatrixStoreToDescriptor:
   case OpCode::LinAlgMatrixAccumulateToDescriptor:
+  case OpCode::LinAlgVectorAccumulateToDescriptor:
     if (FT->getNumParams() <= 1)
       return nullptr;
     return FT->getParamType(1);
@@ -7009,7 +7014,6 @@ llvm::Type *OP::GetOverloadType(OpCode opCode, llvm::Function *F) {
   case OpCode::ClusterID:
   case OpCode::LinAlgMatrixQueryAccumulatorLayout:
   case OpCode::ReservedE0:
-  case OpCode::ReservedE1:
   case OpCode::DebugBreak:
   case OpCode::IsDebuggerPresent:
     return Type::getVoidTy(Ctx);