merge upstream from Microsoft

Author: keptsecret

external/SPIRV-Tools

@@ -945,6 +945,18 @@ def HLSLCXXOverload : InheritableAttr {
   let Documentation = [Undocumented];
 }
 
+// This attribute means something subtly different from the HLSLIntrinsic
+// attribute. Prior to this being introduced a subset of the HLSL intrinsics
+// were placed in the `hlsl` namespace, but not in a way that actually qualified
+// their name lookup. The presence of the namespace as the declcontext was then
+// sused in CGExpr to determine how to emit the call. This attribute replaces
+// the namespace in that context.
+def HLSLBuiltinCall : InheritableAttr {
+  let Spellings = [];
+  let Subjects = SubjectList<[Function]>;
+  let Documentation = [Undocumented];
+}
+
 def HLSLVector : InheritableAttr {
   let Spellings = []; // No spellings!
   let Subjects = SubjectList<[CXXRecord]>;

tools/clang/include/clang/Basic/Attr.td

@@ -678,12 +678,23 @@ class SpirvBuilder {
                bool isPrecise, bool isNointerp, llvm::StringRef name = "",
                llvm::Optional<SpirvInstruction *> init = llvm::None,
                SourceLocation loc = {});
+
+  // Adds a variable to the module.
   SpirvVariable *
   addModuleVar(const SpirvType *valueType, spv::StorageClass storageClass,
                bool isPrecise, bool isNointerp, llvm::StringRef name = "",
                llvm::Optional<SpirvInstruction *> init = llvm::None,
                SourceLocation loc = {});
 
+  // Adds a variable to the module. It will be placed in the variable list
+  // before `pos`.
+  SpirvVariable *
+  addModuleVar(const SpirvType *valueType, spv::StorageClass storageClass,
+               bool isPrecise, bool isNointerp, SpirvInstruction *before,
+               llvm::StringRef name = "",
+               llvm::Optional<SpirvInstruction *> init = llvm::None,
+               SourceLocation loc = {});
+
   /// \brief Decorates the given target with the given location.
   void decorateLocation(SpirvInstruction *target, uint32_t location);
 

tools/clang/include/clang/SPIRV/SpirvBuilder.h

@@ -139,6 +139,10 @@ class SpirvModule {
   // Adds a variable to the module.
   void addVariable(SpirvVariable *);
 
+  // Adds a variable to the module immediately before `pos`.
+  // If `pos` is not found, `var` is added at the end of the variable list.
+  void addVariable(SpirvVariable *var, SpirvInstruction *pos);
+
   // Adds a decoration to the module.
   void addDecoration(SpirvDecoration *);
 
@@ -161,6 +165,10 @@ class SpirvModule {
     return debugInstructions;
   }
 
+  // Access the one DebugCompilationUnit per module
+  SpirvDebugCompilationUnit *getDebugCompilationUnit();
+  void setDebugCompilationUnit(SpirvDebugCompilationUnit *unit);
+
   // Adds the given OpModuleProcessed to the module.
   void addModuleProcessed(SpirvModuleProcessed *);
 
@@ -220,6 +228,10 @@ class SpirvModule {
 
   // Keep all rich DebugInfo instructions.
   llvm::SmallVector<SpirvDebugInstruction *, 32> debugInstructions;
+
+  // There is one debugCompilationUnit per module
+  SpirvDebugCompilationUnit *debugCompilationUnit;
+
   // Whether current module is in pervertex interpolation mode.
   bool perVertexInterp;
 };

tools/clang/include/clang/SPIRV/SpirvModule.h

@@ -3646,14 +3646,8 @@ RValue CodeGenFunction::EmitCallExpr(const CallExpr *E,
     if (unsigned builtinID = FD->getBuiltinID())
       return EmitBuiltinExpr(FD, builtinID, E, ReturnValue);
     // HLSL Change Starts
-    if (getLangOpts().HLSL) {
-      if (const NamespaceDecl *ns = dyn_cast<NamespaceDecl>(FD->getParent())) {
-        if (ns->getName() == "hlsl") {
-          // do hlsl intrinsic generation
-          return EmitHLSLBuiltinCallExpr(FD, E, ReturnValue);
-        }
-      }
-    }
+    if (getLangOpts().HLSL && FD->hasAttr<HLSLBuiltinCallAttr>())
+      return EmitHLSLBuiltinCallExpr(FD, E, ReturnValue);
     // HLSL Change End
   }
 

tools/clang/lib/CodeGen/CGExpr.cpp

@@ -1601,7 +1601,10 @@ void forEachSpirvField(
   uint32_t lastConvertedIndex = 0;
   size_t astFieldIndex = 0;
   for (const auto &base : cxxDecl->bases()) {
-    const auto &type = base.getType();
+    auto type = base.getType();
+    if (auto *templatedType = dyn_cast<SubstTemplateTypeParmType>(type))
+      type = templatedType->getReplacementType();
+
     const auto &spirvField = spirvType->getFields()[astFieldIndex];
     if (!operation(spirvField.fieldIndex, type, spirvField)) {
       return;
@@ -1620,7 +1623,10 @@ void forEachSpirvField(
       continue;
     }
 
-    const auto &type = field->getType();
+    auto type = field->getType();
+    if (auto *templatedType = dyn_cast<SubstTemplateTypeParmType>(type))
+      type = templatedType->getReplacementType();
+
     if (!operation(currentFieldIndex, type, spirvField)) {
       return;
     }

tools/clang/lib/SPIRV/AstTypeProbe.cpp

@@ -62,7 +62,7 @@ SpirvDebugTypeComposite *DebugTypeVisitor::createDebugTypeComposite(
     } else {
       auto *dbgSrc = spvBuilder.createDebugSource(file);
       setDefaultDebugInfo(dbgSrc);
-      auto dbgCompUnit = spvBuilder.createDebugCompilationUnit(dbgSrc);
+      auto dbgCompUnit = spvBuilder.getModule()->getDebugCompilationUnit();
       setDefaultDebugInfo(dbgCompUnit);
       debugInfo =
           &debugInfoMap.insert({file, RichDebugInfo(dbgSrc, dbgCompUnit)})

tools/clang/lib/SPIRV/DebugTypeVisitor.cpp

@@ -1861,7 +1861,7 @@ void DeclResultIdMapper::createCounterVar(
   }
 
   SpirvVariable *counterInstr = spvBuilder.addModuleVar(
-      counterType, sc, /*isPrecise*/ false, false, counterName);
+      counterType, sc, /*isPrecise*/ false, false, declInstr, counterName);
 
   if (!isAlias) {
     // Non-alias counter variables should be put in to resourceVars so that

tools/clang/lib/SPIRV/DeclResultIdMapper.cpp

@@ -136,6 +136,8 @@ uint32_t getHeaderVersion(spv_target_env env) {
 std::string
 ReadSourceCode(llvm::StringRef filePath,
                const clang::spirv::SpirvCodeGenOptions &spvOptions) {
+
+  std::string localFilePath(filePath.begin(), filePath.end());
   try {
     dxc::DxcDllSupport dllSupport;
     IFT(dllSupport.Initialize());
@@ -154,7 +156,10 @@ ReadSourceCode(llvm::StringRef filePath,
   } catch (...) {
     // An exception has occurred while reading the file
     // return the original source (which may have been supplied directly)
-    if (!spvOptions.origSource.empty()) {
+    // only for the main input file
+    if ((!strcmp(localFilePath.c_str(), "hlsl.hlsl") &&
+         spvOptions.inputFile.empty()) ||
+        !strcmp(localFilePath.c_str(), spvOptions.inputFile.c_str())) {
       return spvOptions.origSource.c_str();
     }
     return "";
@@ -2639,80 +2644,15 @@ uint32_t EmitTypeHandler::emitType(const SpirvType *type) {
   // NodePayloadArray types
   else if (const auto *npaType = dyn_cast<NodePayloadArrayType>(type)) {
     const uint32_t elemTypeId = emitType(npaType->getElementType());
+
+    // Output the decorations for the type first. This will create other values
+    // that are on the decorations, and they must appear before the type.
+    emitDecorationsForNodePayloadArrayTypes(npaType, id);
+
     initTypeInstruction(spv::Op::OpTypeNodePayloadArrayAMDX);
     curTypeInst.push_back(id);
     curTypeInst.push_back(elemTypeId);
     finalizeTypeInstruction();
-
-    // Emit decorations
-    const ParmVarDecl *nodeDecl = npaType->getNodeDecl();
-    if (hlsl::IsHLSLNodeOutputType(nodeDecl->getType())) {
-      StringRef name = nodeDecl->getName();
-      unsigned index = 0;
-      if (auto nodeID = nodeDecl->getAttr<HLSLNodeIdAttr>()) {
-        name = nodeID->getName();
-        index = nodeID->getArrayIndex();
-      }
-
-      auto *str = new (context) SpirvConstantString(name);
-      uint32_t nodeName = getOrCreateConstantString(str);
-      emitDecoration(id, spv::Decoration::PayloadNodeNameAMDX, {nodeName},
-                     llvm::None, true);
-      if (index) {
-        uint32_t baseIndex = getOrCreateConstantInt(
-            llvm::APInt(32, index), context.getUIntType(32), false);
-        emitDecoration(id, spv::Decoration::PayloadNodeBaseIndexAMDX,
-                       {baseIndex}, llvm::None, true);
-      }
-    }
-
-    uint32_t maxRecords;
-    if (const auto *attr = nodeDecl->getAttr<HLSLMaxRecordsAttr>()) {
-      maxRecords = getOrCreateConstantInt(llvm::APInt(32, attr->getMaxCount()),
-                                          context.getUIntType(32), false);
-    } else {
-      maxRecords = getOrCreateConstantInt(llvm::APInt(32, 1),
-                                          context.getUIntType(32), false);
-    }
-    emitDecoration(id, spv::Decoration::NodeMaxPayloadsAMDX, {maxRecords},
-                   llvm::None, true);
-
-    if (const auto *attr = nodeDecl->getAttr<HLSLMaxRecordsSharedWithAttr>()) {
-      const DeclContext *dc = nodeDecl->getParentFunctionOrMethod();
-      if (const auto *funDecl = dyn_cast_or_null<FunctionDecl>(dc)) {
-        IdentifierInfo *ii = attr->getName();
-        bool alreadyExists = false;
-        for (auto *paramDecl : funDecl->params()) {
-          if (paramDecl->getIdentifier() == ii) {
-            assert(paramDecl != nodeDecl);
-            auto otherType = context.getNodeDeclPayloadType(paramDecl);
-            const uint32_t otherId =
-                getResultIdForType(otherType, &alreadyExists);
-            assert(alreadyExists && "forward references not allowed in "
-                                    "MaxRecordsSharedWith attribute");
-            emitDecoration(id, spv::Decoration::NodeSharesPayloadLimitsWithAMDX,
-                           {otherId}, llvm::None, true);
-            break;
-          }
-        }
-        assert(alreadyExists &&
-               "invalid reference in MaxRecordsSharedWith attribute");
-      }
-    }
-    if (const auto *attr = nodeDecl->getAttr<HLSLAllowSparseNodesAttr>()) {
-      emitDecoration(id, spv::Decoration::PayloadNodeSparseArrayAMDX, {},
-                     llvm::None);
-    }
-    if (const auto *attr = nodeDecl->getAttr<HLSLUnboundedSparseNodesAttr>()) {
-      emitDecoration(id, spv::Decoration::PayloadNodeSparseArrayAMDX, {},
-                     llvm::None);
-    }
-    if (const auto *attr = nodeDecl->getAttr<HLSLNodeArraySizeAttr>()) {
-      uint32_t arraySize = getOrCreateConstantInt(
-          llvm::APInt(32, attr->getCount()), context.getUIntType(32), false);
-      emitDecoration(id, spv::Decoration::PayloadNodeArraySizeAMDX, {arraySize},
-                     llvm::None, true);
-    }
   }
   // Structure types
   else if (const auto *structType = dyn_cast<StructType>(type)) {
@@ -2993,5 +2933,78 @@ void EmitTypeHandler::emitNameForType(llvm::StringRef name,
                               nameInstr.end());
 }
 
+void EmitTypeHandler::emitDecorationsForNodePayloadArrayTypes(
+    const NodePayloadArrayType *npaType, uint32_t id) {
+  // Emit decorations
+  const ParmVarDecl *nodeDecl = npaType->getNodeDecl();
+  if (hlsl::IsHLSLNodeOutputType(nodeDecl->getType())) {
+    StringRef name = nodeDecl->getName();
+    unsigned index = 0;
+    if (auto nodeID = nodeDecl->getAttr<HLSLNodeIdAttr>()) {
+      name = nodeID->getName();
+      index = nodeID->getArrayIndex();
+    }
+
+    auto *str = new (context) SpirvConstantString(name);
+    uint32_t nodeName = getOrCreateConstantString(str);
+    emitDecoration(id, spv::Decoration::PayloadNodeNameAMDX, {nodeName},
+                   llvm::None, true);
+    if (index) {
+      uint32_t baseIndex = getOrCreateConstantInt(
+          llvm::APInt(32, index), context.getUIntType(32), false);
+      emitDecoration(id, spv::Decoration::PayloadNodeBaseIndexAMDX, {baseIndex},
+                     llvm::None, true);
+    }
+  }
+
+  uint32_t maxRecords;
+  if (const auto *attr = nodeDecl->getAttr<HLSLMaxRecordsAttr>()) {
+    maxRecords = getOrCreateConstantInt(llvm::APInt(32, attr->getMaxCount()),
+                                        context.getUIntType(32), false);
+  } else {
+    maxRecords = getOrCreateConstantInt(llvm::APInt(32, 1),
+                                        context.getUIntType(32), false);
+  }
+  emitDecoration(id, spv::Decoration::NodeMaxPayloadsAMDX, {maxRecords},
+                 llvm::None, true);
+
+  if (const auto *attr = nodeDecl->getAttr<HLSLMaxRecordsSharedWithAttr>()) {
+    const DeclContext *dc = nodeDecl->getParentFunctionOrMethod();
+    if (const auto *funDecl = dyn_cast_or_null<FunctionDecl>(dc)) {
+      IdentifierInfo *ii = attr->getName();
+      bool alreadyExists = false;
+      for (auto *paramDecl : funDecl->params()) {
+        if (paramDecl->getIdentifier() == ii) {
+          assert(paramDecl != nodeDecl);
+          auto otherType = context.getNodeDeclPayloadType(paramDecl);
+          const uint32_t otherId =
+              getResultIdForType(otherType, &alreadyExists);
+          assert(alreadyExists && "forward references not allowed in "
+                                  "MaxRecordsSharedWith attribute");
+          emitDecoration(id, spv::Decoration::NodeSharesPayloadLimitsWithAMDX,
+                         {otherId}, llvm::None, true);
+          break;
+        }
+      }
+      assert(alreadyExists &&
+             "invalid reference in MaxRecordsSharedWith attribute");
+    }
+  }
+  if (const auto *attr = nodeDecl->getAttr<HLSLAllowSparseNodesAttr>()) {
+    emitDecoration(id, spv::Decoration::PayloadNodeSparseArrayAMDX, {},
+                   llvm::None);
+  }
+  if (const auto *attr = nodeDecl->getAttr<HLSLUnboundedSparseNodesAttr>()) {
+    emitDecoration(id, spv::Decoration::PayloadNodeSparseArrayAMDX, {},
+                   llvm::None);
+  }
+  if (const auto *attr = nodeDecl->getAttr<HLSLNodeArraySizeAttr>()) {
+    uint32_t arraySize = getOrCreateConstantInt(
+        llvm::APInt(32, attr->getCount()), context.getUIntType(32), false);
+    emitDecoration(id, spv::Decoration::PayloadNodeArraySizeAMDX, {arraySize},
+                   llvm::None, true);
+  }
+}
+
 } // end namespace spirv
 } // end namespace clang

tools/clang/lib/SPIRV/EmitVisitor.cpp

@@ -135,6 +135,10 @@ class EmitTypeHandler {
   void emitNameForType(llvm::StringRef name, uint32_t targetTypeId,
                        llvm::Optional<uint32_t> memberIndex = llvm::None);
 
+  void
+  emitDecorationsForNodePayloadArrayTypes(const NodePayloadArrayType *npaType,
+                                          uint32_t id);
+
   // There is no guarantee that an instruction or a function or a basic block
   // has been assigned result-id. This method returns the result-id for the
   // given object. If a result-id has not been assigned yet, it'll assign