pr-feedback: variable inheritance

Author: Keenuts

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

@@ -636,7 +636,7 @@ class SpirvBuilder {
   /// support a single entry point per module for now.
   inline void addEntryPoint(spv::ExecutionModel em, SpirvFunction *target,
                             llvm::StringRef targetName,
-                            llvm::ArrayRef<SpirvInstruction *> interfaces);
+                            llvm::ArrayRef<SpirvVariableLike *> interfaces);
   /// \brief Sets the shader model version, source file name, and source file
   /// content. Returns the SpirvString instruction of the file name.
   inline SpirvString *setDebugSource(uint32_t major, uint32_t minor,
@@ -994,7 +994,7 @@ void SpirvBuilder::setMemoryModel(spv::AddressingModel addrModel,
 
 void SpirvBuilder::addEntryPoint(
     spv::ExecutionModel em, SpirvFunction *target, llvm::StringRef targetName,
-    llvm::ArrayRef<SpirvInstruction *> interfaces) {
+    llvm::ArrayRef<SpirvVariableLike *> interfaces) {
   mod->addEntryPoint(new (context) SpirvEntryPoint(
       target->getSourceLocation(), em, target, targetName, interfaces));
 }

tools/clang/include/clang/SPIRV/SpirvInstruction.h

@@ -297,6 +297,14 @@ class SpirvInstruction {
   bool isRasterizerOrdered_;
 };
 
+/// \brief class wrapping OpVariable and OpUntypedVariableKHR
+class SpirvVariableLike : public SpirvInstruction {
+
+protected:
+  SpirvVariableLike(Kind kind, spv::Op opcode, QualType astResultType,
+                    SourceLocation loc, SourceRange range = {});
+};
+
 /// \brief OpCapability instruction
 class SpirvCapability : public SpirvInstruction {
 public:
@@ -391,7 +399,7 @@ class SpirvEntryPoint : public SpirvInstruction {
 public:
   SpirvEntryPoint(SourceLocation loc, spv::ExecutionModel executionModel,
                   SpirvFunction *entryPoint, llvm::StringRef nameStr,
-                  llvm::ArrayRef<SpirvInstruction *> iface);
+                  llvm::ArrayRef<SpirvVariableLike *> iface);
 
   DEFINE_RELEASE_MEMORY_FOR_CLASS(SpirvEntryPoint)
 
@@ -405,15 +413,15 @@ class SpirvEntryPoint : public SpirvInstruction {
   spv::ExecutionModel getExecModel() const { return execModel; }
   SpirvFunction *getEntryPoint() const { return entryPoint; }
   llvm::StringRef getEntryPointName() const { return name; }
-  llvm::ArrayRef<SpirvInstruction *> getInterface() const {
+  llvm::ArrayRef<SpirvVariableLike *> getInterface() const {
     return interfaceVec;
   }
 
 private:
   spv::ExecutionModel execModel;
   SpirvFunction *entryPoint;
   std::string name;
-  llvm::SmallVector<SpirvInstruction *, 8> interfaceVec;
+  llvm::SmallVector<SpirvVariableLike *, 8> interfaceVec;
 };
 
 class SpirvExecutionModeBase : public SpirvInstruction {
@@ -611,7 +619,7 @@ class SpirvDecoration : public SpirvInstruction {
 };
 
 /// \brief OpVariable instruction
-class SpirvVariable : public SpirvInstruction {
+class SpirvVariable : public SpirvVariableLike {
 public:
   SpirvVariable(QualType resultType, SourceLocation loc, spv::StorageClass sc,
                 bool isPrecise, bool isNointerp,
@@ -647,7 +655,7 @@ class SpirvVariable : public SpirvInstruction {
 };
 
 /// \brief OpUntypedVariableKHR instruction
-class SpirvUntypedVariableKHR : public SpirvInstruction {
+class SpirvUntypedVariableKHR : public SpirvVariableLike {
 public:
   SpirvUntypedVariableKHR(QualType resultType, SourceLocation loc,
                           spv::StorageClass sc);

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

@@ -137,11 +137,11 @@ class SpirvModule {
   SpirvExtInstImport *getExtInstSet(llvm::StringRef name);
 
   // Adds a variable to the module.
-  void addVariable(SpirvInstruction *);
+  void addVariable(SpirvVariableLike *);
 
   // 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(SpirvInstruction *var, SpirvInstruction *pos);
+  void addVariable(SpirvVariableLike *var, SpirvInstruction *pos);
 
   // Adds a decoration to the module.
   void addDecoration(SpirvDecoration *);
@@ -172,7 +172,7 @@ class SpirvModule {
   // Adds the given OpModuleProcessed to the module.
   void addModuleProcessed(SpirvModuleProcessed *);
 
-  llvm::ArrayRef<SpirvInstruction *> getVariables() const { return variables; }
+  llvm::ArrayRef<SpirvVariableLike *> getVariables() const { return variables; }
 
   llvm::ArrayRef<SpirvEntryPoint *> getEntryPoints() const {
     return entryPoints;
@@ -217,7 +217,7 @@ class SpirvModule {
 
   std::vector<SpirvConstant *> constants;
   std::vector<SpirvUndef *> undefs;
-  std::vector<SpirvInstruction *> variables;
+  std::vector<SpirvVariableLike *> variables;
   // A vector of functions in the module in the order that they should be
   // emitted. The order starts with the entry-point function followed by a
   // depth-first discovery of functions reachable from the entry-point function.

tools/clang/lib/SPIRV/DeclResultIdMapper.cpp

@@ -1173,7 +1173,7 @@ DeclResultIdMapper::createFileVar(const VarDecl *var,
   return varInstr;
 }
 
-SpirvInstruction *
+SpirvVariableLike *
 DeclResultIdMapper::createResourceDescriptorHeap(const VarDecl *var) {
   SpirvUntypedVariableKHR *HeapVar = nullptr;
 
@@ -1209,15 +1209,15 @@ DeclResultIdMapper::createResourceDescriptorHeap(const VarDecl *var) {
   return HeapVar;
 }
 
-SpirvInstruction *
+SpirvVariableLike *
 DeclResultIdMapper::createEmulatedDescriptorHeap(const VarDecl *var,
                                                  QualType resourceType) {
   QualType ResourceArrayType = astContext.getIncompleteArrayType(
       resourceType, clang::ArrayType::Normal, 0);
   return createExternVar(var, ResourceArrayType);
 }
 
-SpirvInstruction *
+SpirvVariableLike *
 DeclResultIdMapper::createResourceHeap(const VarDecl *var,
                                        QualType resourceType) {
   if (spirvOptions.useDescriptorHeap)
@@ -1999,9 +1999,9 @@ void DeclResultIdMapper::createFieldCounterVars(
   }
 }
 
-std::vector<SpirvInstruction *>
+std::vector<SpirvVariableLike *>
 DeclResultIdMapper::collectStageVars(SpirvFunction *entryPoint) const {
-  std::vector<SpirvInstruction *> vars;
+  std::vector<SpirvVariableLike *> vars;
 
   for (auto var : glPerVertex.getStageInVars())
     vars.push_back(var);

tools/clang/lib/SPIRV/DeclResultIdMapper.h

@@ -291,7 +291,7 @@ class DeclResultIdMapper {
 
   /// Creates a global variable for resource heaps containing elements of type
   /// |type|.
-  SpirvInstruction *createResourceHeap(const VarDecl *var, QualType type);
+  SpirvVariableLike *createResourceHeap(const VarDecl *var, QualType type);
 
   /// \brief Creates an external-visible variable and returns its instruction.
   SpirvVariable *createExternVar(const VarDecl *var);
@@ -510,7 +510,7 @@ class DeclResultIdMapper {
 
   /// \brief Returns all defined stage (builtin/input/ouput) variables for the
   /// entry point function entryPoint in this mapper.
-  std::vector<SpirvInstruction *>
+  std::vector<SpirvVariableLike *>
   collectStageVars(SpirvFunction *entryPoint) const;
 
   /// \brief Writes out the contents in the function parameter for the GS
@@ -1007,12 +1007,12 @@ class DeclResultIdMapper {
   void registerVariableForDecl(const VarDecl *var, DeclSpirvInfo spirvInfo);
 
   /// Creates a global variable for resource heaps using VK_EXT_descriptor_heap.
-  SpirvInstruction *createResourceDescriptorHeap(const VarDecl *var);
+  SpirvVariableLike *createResourceDescriptorHeap(const VarDecl *var);
 
   /// Creates a global variable for resource heaps containing elements of type
   /// |type| (emulated descriptor heaps).
-  SpirvInstruction *createEmulatedDescriptorHeap(const VarDecl *var,
-                                                 QualType resourceType);
+  SpirvVariableLike *createEmulatedDescriptorHeap(const VarDecl *var,
+                                                  QualType resourceType);
 
 private:
   SpirvBuilder &spvBuilder;

tools/clang/lib/SPIRV/SpirvEmitter.cpp

@@ -696,24 +696,20 @@ SpirvEmitter::SpirvEmitter(CompilerInstance &ci)
   }
 }
 
-std::vector<SpirvInstruction *>
+std::vector<SpirvVariableLike *>
 SpirvEmitter::getInterfacesForEntryPoint(SpirvFunction *entryPoint) {
   auto stageVars = declIdMapper.collectStageVars(entryPoint);
-  if (!featureManager.isTargetEnvVulkan1p1Spirv1p4OrAbove()) {
-    std::vector<SpirvInstruction *> ifaces;
-    for (auto *v : stageVars)
-      ifaces.push_back(v);
-    return ifaces;
-  }
+  if (!featureManager.isTargetEnvVulkan1p1Spirv1p4OrAbove())
+    return stageVars;
 
   // In SPIR-V 1.4 or above, we must include global variables in the 'Interface'
   // operands of OpEntryPoint. SpirvModule keeps all global variables, but some
   // of them can be duplicated with stage variables kept by declIdMapper. Since
   // declIdMapper keeps the mapping between variables with Input or Output
   // storage class and their storage class, we have to rely on
   // declIdMapper.collectStageVars() to collect them.
-  llvm::SetVector<SpirvInstruction *> interfaces(stageVars.begin(),
-                                                 stageVars.end());
+  llvm::SetVector<SpirvVariableLike *> interfaces(stageVars.begin(),
+                                                  stageVars.end());
 
   for (auto *moduleVar : spvBuilder.getModule()->getVariables()) {
     if (moduleVar->getStorageClass() == spv::StorageClass::Input ||
@@ -733,7 +729,7 @@ SpirvEmitter::getInterfacesForEntryPoint(SpirvFunction *entryPoint) {
     }
     interfaces.insert(moduleVar);
   }
-  std::vector<SpirvInstruction *> interfacesInVector;
+  std::vector<SpirvVariableLike *> interfacesInVector;
   interfacesInVector.reserve(interfaces.size());
   for (auto *interface : interfaces) {
     interfacesInVector.push_back(interface);

tools/clang/lib/SPIRV/SpirvEmitter.h

@@ -1320,7 +1320,7 @@ class SpirvEmitter : public ASTConsumer {
 
   /// \brief Returns OpVariable to be used as 'Interface' operands of
   /// OpEntryPoint. entryPoint is the SpirvFunction for the OpEntryPoint.
-  std::vector<SpirvInstruction *>
+  std::vector<SpirvVariableLike *>
   getInterfacesForEntryPoint(SpirvFunction *entryPoint);
 
   /// \brief Emits OpBeginInvocationInterlockEXT and add the appropriate

tools/clang/lib/SPIRV/SpirvInstruction.cpp

@@ -207,7 +207,7 @@ SpirvEntryPoint::SpirvEntryPoint(SourceLocation loc,
                                  spv::ExecutionModel executionModel,
                                  SpirvFunction *entryPointFn,
                                  llvm::StringRef nameStr,
-                                 llvm::ArrayRef<SpirvInstruction *> iface)
+                                 llvm::ArrayRef<SpirvVariableLike *> iface)
     : SpirvInstruction(IK_EntryPoint, spv::Op::OpEntryPoint, QualType(), loc),
       execModel(executionModel), entryPoint(entryPointFn), name(nameStr),
       interfaceVec(iface.begin(), iface.end()) {}
@@ -310,7 +310,7 @@ bool SpirvDecoration::operator==(const SpirvDecoration &that) const {
 SpirvVariable::SpirvVariable(QualType resultType, SourceLocation loc,
                              spv::StorageClass sc, bool precise,
                              bool isNointerp, SpirvInstruction *initializerInst)
-    : SpirvInstruction(IK_Variable, spv::Op::OpVariable, resultType, loc),
+    : SpirvVariableLike(IK_Variable, spv::Op::OpVariable, resultType, loc),
       initializer(initializerInst), descriptorSet(-1), binding(-1),
       hlslUserType("") {
   setStorageClass(sc);
@@ -321,7 +321,7 @@ SpirvVariable::SpirvVariable(QualType resultType, SourceLocation loc,
 SpirvVariable::SpirvVariable(const SpirvType *spvType, SourceLocation loc,
                              spv::StorageClass sc, bool precise,
                              bool isNointerp, SpirvInstruction *initializerInst)
-    : SpirvInstruction(IK_Variable, spv::Op::OpVariable, QualType(), loc),
+    : SpirvVariableLike(IK_Variable, spv::Op::OpVariable, QualType(), loc),
       initializer(initializerInst), descriptorSet(-1), binding(-1),
       hlslUserType("") {
   setResultType(spvType);
@@ -333,20 +333,25 @@ SpirvVariable::SpirvVariable(const SpirvType *spvType, SourceLocation loc,
 SpirvUntypedVariableKHR::SpirvUntypedVariableKHR(QualType resultType,
                                                  SourceLocation loc,
                                                  spv::StorageClass sc)
-    : SpirvInstruction(IK_UntypedVariableKHR, spv::Op::OpUntypedVariableKHR,
-                       resultType, loc) {
+    : SpirvVariableLike(IK_UntypedVariableKHR, spv::Op::OpUntypedVariableKHR,
+                        resultType, loc) {
   setStorageClass(sc);
 }
 
 SpirvUntypedVariableKHR::SpirvUntypedVariableKHR(const SpirvType *spvType,
                                                  SourceLocation loc,
                                                  spv::StorageClass sc)
-    : SpirvInstruction(IK_UntypedVariableKHR, spv::Op::OpUntypedVariableKHR,
-                       QualType(), loc) {
+    : SpirvVariableLike(IK_UntypedVariableKHR, spv::Op::OpUntypedVariableKHR,
+                        QualType(), loc) {
   setResultType(spvType);
   setStorageClass(sc);
 }
 
+SpirvVariableLike::SpirvVariableLike(Kind kind, spv::Op opcode,
+                                     QualType astResultType, SourceLocation loc,
+                                     SourceRange range)
+    : SpirvInstruction(kind, opcode, astResultType, loc, range) {}
+
 SpirvUntypedAccessChainKHR::SpirvUntypedAccessChainKHR(
     const SpirvType *resultType, SourceLocation loc, const SpirvType *baseType,
     SpirvInstruction *baseInst, llvm::ArrayRef<SpirvInstruction *> indexVec)

tools/clang/lib/SPIRV/SpirvModule.cpp

@@ -336,12 +336,12 @@ SpirvExtInstImport *SpirvModule::getExtInstSet(llvm::StringRef name) {
   return nullptr;
 }
 
-void SpirvModule::addVariable(SpirvInstruction *var) {
+void SpirvModule::addVariable(SpirvVariableLike *var) {
   assert(var && "cannot add null variable to the module");
   variables.push_back(var);
 }
 
-void SpirvModule::addVariable(SpirvInstruction *var, SpirvInstruction *pos) {
+void SpirvModule::addVariable(SpirvVariableLike *var, SpirvInstruction *pos) {
   assert(var && "cannot add null variable to the module");
   auto location = std::find(variables.begin(), variables.end(), pos);
   variables.insert(location, var);