Gate O1experimental fast path on risky composite types

Author: AnastaZIuk

tools/clang/lib/SPIRV/SpirvEmitter.cpp

@@ -29,6 +29,8 @@
 #include "clang/SPIRV/String.h"
 #include "clang/Sema/Sema.h"
 #include "llvm/ADT/APInt.h"
+#include "llvm/ADT/SmallPtrSet.h"
+#include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/SetVector.h"
 #include "llvm/ADT/StringExtras.h"
 #include "llvm/Support/Casting.h"
@@ -596,6 +598,7 @@ SpirvEmitter::SpirvEmitter(CompilerInstance &ci)
       needsLegalizationLoopUnroll(false),
       needsLegalizationSsaRewrite(false),
       sawExplicitUnrollHint(false),
+      experimentalFastCompileRequiresDefaultPath(false),
       beforeHlslLegalization(false), mainSourceFile(nullptr) {
 
   // Get ShaderModel from command line hlsl profile option.
@@ -1570,6 +1573,84 @@ bool SpirvEmitter::handleNodePayloadArrayType(const ParmVarDecl *decl,
   }
 }
 
+void SpirvEmitter::noteExperimentalFastCompileRisk(
+    QualType type, bool hasAliasedPointerAttr) {
+  if (!spirvOptions.o1ExperimentalFastCompile || type.isNull())
+    return;
+
+  auto hasRiskyDecorations = [](const Decl *decl) {
+    if (!decl || !decl->hasAttrs())
+      return false;
+
+    if (decl->hasAttr<VKAliasedPointerAttr>())
+      return true;
+
+    for (const auto *attr : decl->getAttrs()) {
+      if (const auto *decorateAttr = dyn_cast<VKDecorateExtAttr>(attr)) {
+        const auto decoration =
+            static_cast<spv::Decoration>(decorateAttr->getDecorate());
+        if (decoration == spv::Decoration::AliasedPointer ||
+            decoration == spv::Decoration::RestrictPointer) {
+          return true;
+        }
+      }
+    }
+    return false;
+  };
+
+  llvm::SmallVector<QualType, 8> worklist;
+  llvm::SmallPtrSet<const Type *, 16> visitedTypes;
+  worklist.push_back(type);
+
+  while (!worklist.empty()) {
+    QualType currentType = worklist.pop_back_val();
+    if (currentType.isNull())
+      continue;
+
+    Optional<bool> isRowMajor = llvm::None;
+    currentType = desugarType(currentType, &isRowMajor);
+
+    const Type *typePtr = currentType.getTypePtrOrNull();
+    if (!typePtr || !visitedTypes.insert(typePtr).second)
+      continue;
+
+    if (hasAliasedPointerAttr || hlsl::IsVKBufferPointerType(currentType) ||
+        isOpaqueArrayType(currentType) || isOpaqueStructType(currentType) ||
+        isBindlessOpaqueArray(currentType)) {
+      experimentalFastCompileRequiresDefaultPath = true;
+      return;
+    }
+
+    if (const auto *arrayType = currentType->getAsArrayTypeUnsafe()) {
+      worklist.push_back(arrayType->getElementType());
+      continue;
+    }
+
+    const auto *recordType = currentType->getAs<RecordType>();
+    if (!recordType)
+      continue;
+
+    const RecordDecl *recordDecl = recordType->getDecl();
+    if (hasRiskyDecorations(recordDecl)) {
+      experimentalFastCompileRequiresDefaultPath = true;
+      return;
+    }
+
+    if (const auto *cxxRecordDecl = dyn_cast<CXXRecordDecl>(recordDecl)) {
+      for (const auto &base : cxxRecordDecl->bases())
+        worklist.push_back(base.getType());
+    }
+
+    for (const FieldDecl *fieldDecl : recordDecl->fields()) {
+      if (hasRiskyDecorations(fieldDecl)) {
+        experimentalFastCompileRequiresDefaultPath = true;
+        return;
+      }
+      worklist.push_back(fieldDecl->getType());
+    }
+  }
+}
+
 void SpirvEmitter::doFunctionDecl(const FunctionDecl *decl) {
   // Forward declaration of a function inside another.
   if (!decl->isThisDeclarationADefinition()) {
@@ -1578,6 +1659,8 @@ void SpirvEmitter::doFunctionDecl(const FunctionDecl *decl) {
     return;
   }
 
+  noteExperimentalFastCompileRisk(decl->getReturnType());
+
   // A RAII class for maintaining the current function under traversal.
   class FnEnvRAII {
   public:
@@ -1682,6 +1765,7 @@ void SpirvEmitter::doFunctionDecl(const FunctionDecl *decl) {
       // For non-static member function, the first parameter should be the
       // object on which we are invoking this method.
       QualType valueType = memberFn->getThisType(astContext)->getPointeeType();
+      noteExperimentalFastCompileRisk(valueType);
 
       // Remember the parameter for the 'this' object so later we can handle
       // CXXThisExpr correctly.
@@ -1716,6 +1800,8 @@ void SpirvEmitter::doFunctionDecl(const FunctionDecl *decl) {
   for (uint32_t i = 0; i < decl->getNumParams(); ++i) {
     const ParmVarDecl *paramDecl = decl->getParamDecl(i);
     QualType paramType = paramDecl->getType();
+    noteExperimentalFastCompileRisk(paramType,
+                                    paramDecl->hasAttr<VKAliasedPointerAttr>());
     auto *param =
         declIdMapper.createFnParam(paramDecl, i + 1 + isNonStaticMemberFn);
     if (isEntry) {
@@ -2038,6 +2124,8 @@ void SpirvEmitter::doVarDecl(const VarDecl *decl) {
 
   const auto loc = decl->getLocation();
   const auto range = decl->getSourceRange();
+  noteExperimentalFastCompileRisk(decl->getType(),
+                                  decl->hasAttr<VKAliasedPointerAttr>());
 
   if (isExtResultIdType(decl->getType())) {
     declIdMapper.createResultId(decl);
@@ -16670,7 +16758,9 @@ bool SpirvEmitter::spirvToolsOptimize(std::vector<uint32_t> *mod,
 
 bool SpirvEmitter::useSpirvFastCompileProfile() const {
   return spirvOptions.o1ExperimentalFastCompile &&
-         spirvOptions.optConfig.empty();
+         spirvOptions.optConfig.empty() &&
+         !experimentalFastCompileRequiresDefaultPath &&
+         !declIdMapper.requiresFlatteningCompositeResources();
 }
 
 bool SpirvEmitter::spirvToolsLegalize(std::vector<uint32_t> *mod,

tools/clang/lib/SPIRV/SpirvEmitter.h

@@ -1340,6 +1340,8 @@ class SpirvEmitter : public ASTConsumer {
   /// Returns true on success and false otherwise.
   bool spirvToolsOptimize(std::vector<uint32_t> *mod, std::string *messages);
   bool useSpirvFastCompileProfile() const;
+  void noteExperimentalFastCompileRisk(QualType type,
+                                       bool hasAliasedPointerAttr = false);
 
   // \brief Runs the pass represented by the given pass token on the module.
   // Returns true if the pass was successfully run. Any messages from the
@@ -1582,6 +1584,7 @@ class SpirvEmitter : public ASTConsumer {
   bool needsLegalizationLoopUnroll;
   bool needsLegalizationSsaRewrite;
   bool sawExplicitUnrollHint;
+  bool experimentalFastCompileRequiresDefaultPath;
 
   /// Whether the translated SPIR-V binary passes --before-hlsl-legalization
   /// option to spirv-val because of illegal function parameter scope.