[mlir] Add an 'cppNamespace' field to availability

[antiagainst]

Summary

This allows us to generate interfaces in a namespace,
following other TableGen'erated code.

Depends On D108310

[rriddle]

mlir/include/mlir/Dialect/SPIRV/IR/SPIRVAvailability.td

23

Would it be possible to use cppNamespace instead? That matches the naming scheme used everywhere else.

mlir/tools/mlir-tblgen/SPIRVUtilsGen.cpp

259

Can you use the NamespaceEmitter util instead?

https://github.com/llvm/llvm-project/blob/e100a41bbe61713b25abf27216775334585b477c/mlir/include/mlir/TableGen/CodeGenHelpers.h#L47

[antiagainst]

Address comments

mlir/tools/mlir-tblgen/SPIRVUtilsGen.cpp

259

Oh, didn't know about that. Changed.

mlir/include/mlir/Dialect/SPIRV/IR/SPIRVAvailability.td

 //===----------------------------------------------------------------------===//
 // Op availability definitions
 //===----------------------------------------------------------------------===//
 
 // The base class for defining op availability dimensions.
 class Availability {
   // The following are fields for controlling the generated C++ OpInterface.
 
+  // The namespace for the generated C++ OpInterface subclass.
+  string cppNamespace = ?;
   // The name for the generated C++ OpInterface subclass.
   string interfaceName = ?;
   // The documentation for the generated C++ OpInterface subclass.
   string interfaceDescription = "";
 
   // The following are fields for controlling the query function signature.
 
   // The query function's return type in the generated C++ OpInterface subclass.

mlir/include/mlir/Dialect/SPIRV/IR/SPIRVBase.td

 def SPV_V_1_4 : I32EnumAttrCase<"V_1_4", 4, "v1.4">;
 def SPV_V_1_5 : I32EnumAttrCase<"V_1_5", 5, "v1.5">;
 
 def SPV_VersionAttr : SPV_I32EnumAttr<"Version", "valid SPIR-V version", [
     SPV_V_1_0, SPV_V_1_1, SPV_V_1_2, SPV_V_1_3, SPV_V_1_4, SPV_V_1_5]>;
 
 class MinVersion<I32EnumAttrCase min> : MinVersionBase<
     "QueryMinVersionInterface", SPV_VersionAttr, min> {
+  let cppNamespace = "::mlir::spirv";
   let interfaceDescription = [{
     Querying interface for minimal required SPIR-V version.
 
     This interface provides a `getMinVersion()` method to query the minimal
     required version for the implementing SPIR-V operation. The returned value
     is a `mlir::spirv::Version` enumerant.
   }];
 }
 
 class MaxVersion<I32EnumAttrCase max> : MaxVersionBase<
     "QueryMaxVersionInterface", SPV_VersionAttr, max> {
+  let cppNamespace = "::mlir::spirv";
   let interfaceDescription = [{
     Querying interface for maximal supported SPIR-V version.
 
     This interface provides a `getMaxVersion()` method to query the maximal
     supported version for the implementing SPIR-V operation. The returned value
     is a `mlir::spirv::Version` enumerant.
   }];
 }
 
 class Extension<list<StrEnumAttrCase> extensions> : Availability {
+  let cppNamespace = "::mlir::spirv";
   let interfaceName = "QueryExtensionInterface";
   let interfaceDescription = [{
     Querying interface for required SPIR-V extensions.
 
     This interface provides a `getExtensions()` method to query the required
     extensions for the implementing SPIR-V operation. The returned value
     is a nested vector whose element is `mlir::spirv::Extension`s. The outer
     vector's elements (which are vectors) should be interpreted as conjunction
let instancePreparation = !if(!empty(extensions), "",
     "}; " #
     // The following manual ArrayRef constructor call is to satisfy GCC 5.
     "ArrayRef<::mlir::spirv::Extension> " #
       "ref(exts, ::llvm::array_lengthof(exts));");
   let instance = "ref";
 }
 
 class Capability<list<I32EnumAttrCase> capabilities> : Availability {
+  let cppNamespace = "::mlir::spirv";
   let interfaceName = "QueryCapabilityInterface";
   let interfaceDescription = [{
     Querying interface for required SPIR-V capabilities.
 
     This interface provides a `getCapabilities()` method to query the required
     capabilities for the implementing SPIR-V operation. The returned value
     is a nested vector whose element is `mlir::spirv::Capability`s. The outer
     vector's elements (which are vectors) should be interpreted as conjunction

mlir/include/mlir/Dialect/SPIRV/IR/SPIRVOps.h

 #include "mlir/Dialect/SPIRV/IR/SPIRVOpTraits.h"
 #include "mlir/Dialect/SPIRV/IR/SPIRVTypes.h"
 #include "mlir/IR/BuiltinOps.h"
 #include "mlir/IR/OpImplementation.h"
 #include "mlir/Interfaces/ControlFlowInterfaces.h"
 #include "mlir/Interfaces/SideEffectInterfaces.h"
 #include "llvm/Support/PointerLikeTypeTraits.h"
 
+// TableGen'erated operation interfaces for querying versions, extensions, and
+// capabilities.
+#include "mlir/Dialect/SPIRV/IR/SPIRVAvailability.h.inc"
+
 namespace mlir {
 class OpBuilder;
 
 namespace spirv {
 class VerCapExtAttr;
-
-// TableGen'erated operation interfaces for querying versions, extensions, and
-// capabilities.
-#include "mlir/Dialect/SPIRV/IR/SPIRVAvailability.h.inc"
 } // namespace spirv
 } // namespace mlir
 
 // TablenGen'erated operation declarations.
 #define GET_OP_CLASSES
 #include "mlir/Dialect/SPIRV/IR/SPIRVOps.h.inc"
 
 namespace llvm {

mlir/lib/Dialect/SPIRV/IR/SPIRVOps.cpp

static LogicalResult verify(spirv::ImageQuerySizeOp imageQuerySizeOp) {
   if (componentNumber != resultComponentNumber)
     return imageQuerySizeOp.emitError("expected the result to have ")
            << componentNumber << " component(s), but found "
            << resultComponentNumber << " component(s)";
 
   return success();
 }
 
-namespace mlir {
-namespace spirv {
-
 // TableGen'erated operation interfaces for querying versions, extensions, and
 // capabilities.
 #include "mlir/Dialect/SPIRV/IR/SPIRVAvailability.cpp.inc"
-} // namespace spirv
-} // namespace mlir
 
 // TablenGen'erated operation definitions.
 #define GET_OP_CLASSES
 #include "mlir/Dialect/SPIRV/IR/SPIRVOps.cpp.inc"
 
 namespace mlir {
 namespace spirv {
 // TableGen'erated operation availability interface implementations.
 #include "mlir/Dialect/SPIRV/IR/SPIRVOpAvailabilityImpl.inc"
-
 } // namespace spirv
 } // namespace mlir

mlir/tools/mlir-tblgen/SPIRVUtilsGen.cpp

 //===- SPIRVSerializationGen.cpp - SPIR-V serialization utility generator -===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // SPIRVSerializationGen generates common utility functions for SPIR-V
 // serialization.
 //
 //===----------------------------------------------------------------------===//
 
 #include "mlir/TableGen/Attribute.h"
+#include "mlir/TableGen/CodeGenHelpers.h"
 #include "mlir/TableGen/Format.h"
 #include "mlir/TableGen/GenInfo.h"
 #include "mlir/TableGen/Operator.h"
 #include "llvm/ADT/Sequence.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/StringExtras.h"
 #include "llvm/ADT/StringMap.h"
 #include "llvm/ADT/StringRef.h"

 using llvm::StringMap;
 using llvm::StringRef;
 using llvm::Twine;
 using mlir::tblgen::Attribute;
 using mlir::tblgen::EnumAttr;
 using mlir::tblgen::EnumAttrCase;
 using mlir::tblgen::NamedAttribute;
 using mlir::tblgen::NamedTypeConstraint;
+using mlir::tblgen::NamespaceEmitter;
 using mlir::tblgen::Operator;
 
 //===----------------------------------------------------------------------===//
 // Availability Wrapper Class
 //===----------------------------------------------------------------------===//
 
 namespace {
 // Wrapper class with helper methods for accessing availability defined in
 // TableGen.
 class Availability {
 public:
   explicit Availability(const Record *def);
 
   // Returns the name of the direct TableGen class for this availability
   // instance.
   StringRef getClass() const;
 
+  // Returns the generated C++ interface's class namespace.
+  StringRef getInterfaceClassNamespace() const;
+
   // Returns the generated C++ interface's class name.
   StringRef getInterfaceClassName() const;
 
   // Returns the generated C++ interface's description.
   StringRef getInterfaceDescription() const;
 
   // Returns the name of the query function insided the generated C++ interface.
   StringRef getQueryFnName() const;
public:
   StringRef getMergeInstanceType() const;
 
   // Returns the C++ statements for preparing availability instance.
   StringRef getMergeInstancePreparation() const;
 
   // Returns the concrete availability instance carried in this case.
   StringRef getMergeInstance() const;
 
+  // Returns the underlying LLVM TableGen Record.
+  const llvm::Record *getDef() const { return def; }
+
 private:
   // The TableGen definition of this availability.
   const llvm::Record *def;
 };
 } // namespace
 
 Availability::Availability(const llvm::Record *def) : def(def) {
   assert(def->isSubClassOf("Availability") &&
          "must be subclass of TableGen 'Availability' class");
 }
 
 StringRef Availability::getClass() const {
   SmallVector<Record *, 1> parentClass;
   def->getDirectSuperClasses(parentClass);
   if (parentClass.size() != 1) {
     PrintFatalError(def->getLoc(),
                     "expected to only have one direct superclass");
   }
   return parentClass.front()->getName();
 }
 
+StringRef Availability::getInterfaceClassNamespace() const {
+  return def->getValueAsString("cppNamespace");
+}
+
 StringRef Availability::getInterfaceClassName() const {
   return def->getValueAsString("interfaceName");
 }
 
 StringRef Availability::getInterfaceDescription() const {
   return def->getValueAsString("interfaceDescription");
 }
 

 }
 
 //===----------------------------------------------------------------------===//
 // Availability Interface Definitions AutoGen
 //===----------------------------------------------------------------------===//
 
 static void emitInterfaceDef(const Availability &availability,
                              raw_ostream &os) {
+
+  os << availability.getQueryFnRetType() << " ";
+
+  StringRef cppNamespace = availability.getInterfaceClassNamespace();
+  cppNamespace.consume_front("::");
+  if (!cppNamespace.empty())
+    os << cppNamespace << "::";
+
   StringRef methodName = availability.getQueryFnName();
-  os << availability.getQueryFnRetType() << " "
-     << availability.getInterfaceClassName() << "::" << methodName << "() {\n"
+  os << availability.getInterfaceClassName() << "::" << methodName << "() {\n"
      << "  return getImpl()->" << methodName << "(getImpl(), getOperation());\n"
      << "}\n";
 }
 
 static bool emitInterfaceDefs(const RecordKeeper &recordKeeper,
                               raw_ostream &os) {
   llvm::emitSourceFileHeader("Availability Interface Definitions", os);
 

 }
 
 static void emitInterfaceDecl(const Availability &availability,
                               raw_ostream &os) {
   StringRef interfaceName = availability.getInterfaceClassName();
   std::string interfaceTraitsName =
       std::string(formatv("{0}Traits", interfaceName));
 
+  StringRef cppNamespace = availability.getInterfaceClassNamespace();
+  NamespaceEmitter nsEmitter(os, cppNamespace);
+
   // Emit the traits struct containing the concept and model declarations.
   os << "namespace detail {\n"
      << "struct " << interfaceTraitsName << " {\n";
   emitConceptDecl(availability, os);
   os << '\n';
   emitModelDecl(availability, os);
-  os << "};\n} // end namespace detail\n\n";
+  os << "};\n} // namespace detail\n\n";
 
   // Emit the main interface class declaration.
   os << "/*\n" << availability.getInterfaceDescription().trim() << "\n*/\n";
   os << llvm::formatv("class {0} : public OpInterface<{1}, detail::{2}> {\n"
                       "public:\n"
                       "  using OpInterface<{1}, detail::{2}>::OpInterface;\n",
                       interfaceName, interfaceName, interfaceTraitsName);