WIP: DSL-style builder generator

[jurahul]

Overall, should we discuss whether we want a per-dialect builder or put that on per-op (i.e, Op::create) to not have another object involved in this (the dialect builder). I know you had pointed me to an earlier discussion, I didn't get an opportunity to carry it forward.

mlir/tools/mlir-tblgen/OpDefinitionsGen.cpp

2249

FYI: I just added an OpMethodParameter to represent something like this. May be the OpMethodParameters create() functions can have this parsing logic and vend out an OpMethodResolvedParameters objects instead of the current OpMethodUnresolvedParameters?

[ftynse]

I have sent an RFC to which this diff is in illustration. Please do not review diffs with work-in-progress / WIP in the title.

mlir/tools/mlir-tblgen/OpDefinitionsGen.cpp

static bool emitOpDefs(const RecordKeeper &recordKeeper, raw_ostream &os) {
 
   const auto &defs = getAllDerivedDefinitions(recordKeeper, "Op");
   emitOpList(defs, os);
   emitOpClasses(defs, os, /*emitDecl=*/false);
 
   return false;
 }
 
+struct ArgumentSignature {
+  StringRef type;
+  StringRef name;
+  StringRef initializer;
+};
+
+static ArgumentSignature splitSignature(StringRef signature) {
+  signature = signature.trim();
+
+  // First, check if there is an initializer. We find it by looking for the
+  // first '=' because these are unlikely (althought not impossible) to find in
+  // the type signature.
+  size_t assignmentPos = signature.find('=');
+  StringRef initializer;
+  if (assignmentPos != std::string::npos) {
+    initializer = signature.drop_front(assignmentPos + 1).ltrim();
+    signature = signature.take_front(assignmentPos).rtrim();
+  }
+
+  for (int64_t pos = signature.size() - 1; pos >= 0; --pos) {
+    // Iterate until we find a symbol that is clearly not a part of an
+    // identifier.
+    char c = signature[pos];
+    if (isAlnum(c) || c == '_')
+      continue;
+
+    // The part may be a name or a reserved keyword that belongs to the type,
+    // e.g., in "Type *const" the "const" part belongs to the type. Check if the
+    // identifier is a keyword or not before forming the type/name pair.
+    StringRef maybeName = signature.drop_front(pos + 1);
+    if (maybeName.trim() == "const" || maybeName.trim() == "volatile")
+      return {signature, StringRef(), initializer};
+    return {signature.take_front(pos + 1).rtrim(),
+            signature.drop_front(pos + 1), initializer};
+  }
+
+  // If we only found characters that can form identifier, it's a type
+  // identifier rather than name.
+  return {signature, StringRef(), initializer};
+}
+
+// The builder signature is a comma-separated argument list. But it can also
+// have commas inside template argument list. Filter those out.
+static void splitBuilderSignature(StringRef signature,
+                                  SmallVectorImpl<StringRef> &arguments) {
+  size_t numAngleBrackets = 0;
+  size_t start = 0;
+  for (size_t pos = 0; pos < signature.size(); ++pos) {
+    if (signature[pos] == '<') {
+      ++numAngleBrackets;
+    } else if (signature[pos] == '>') {
+      assert(numAngleBrackets > 0 && "unexpected syntax error");
+      --numAngleBrackets;
+    } else if (signature[pos] == ',' && numAngleBrackets == 0) {
+      arguments.push_back(signature.substr(start, pos - start));
+      start = pos + 1;
+    }
+  }
+  arguments.push_back(signature.drop_front(start));
+}
+
+static std::string formatOneArg(StringRef type, Twine name, StringRef init) {
+  if (init.empty())
+    return formatv("{0} {1}", type, name).str();
+  return formatv("{0} {1} = {2}", type, name, init).str();
+}
+
+static void emitOneBuilderDef(const Record &def, raw_ostream &os) {
+  ListInit *listInit = dyn_cast_or_null<ListInit>(def.getValueInit("builders"));
+  if (!listInit)
+    return;
+
+  Operator op(def);
+  for (Init *init : listInit->getValues()) {
+    Record *builderDef = cast<DefInit>(init)->getDef();
+    StringRef params = builderDef->getValueAsString("params");
+
+    SmallVector<StringRef, 8> args;
+    splitBuilderSignature(params, args);
+    assert(args.size() >= 2 &&
+           "expected at least an OpBuilder and a state in builder args");
+    assert(args[0].trim().startswith("OpBuilder") &&
+           "expected first builder arg to be OpBuilder");
+    assert(args[1].trim().startswith("OperationState") &&
+           "expected second builder arg to be OperationState");
+
+    std::string typeNameList, nameList;
+    llvm::raw_string_ostream typeNameStream(typeNameList), nameStream(nameList);
+
+    for (auto en : llvm::enumerate(llvm::makeArrayRef(args).drop_front(2))) {
+      ArgumentSignature signature = splitSignature(en.value());
+      std::string name = signature.name.empty()
+                             ? formatv("odsArgument{0}", en.index()).str()
+                             : signature.name.str();
+
+      typeNameStream << signature.type << ' ' << name;
+      if (!signature.initializer.empty())
+        typeNameStream << " = " << signature.initializer;
+      if (en.index() != args.size() - 3)
+        typeNameStream << ", ";
+
+      nameStream << name;
+      if (en.index() != args.size() - 3)
+        nameStream << ", ";
+    }
+
+    os << formatv("  {0} {0}({1}) {{\n", op.getCppClassName(),
+                  typeNameStream.str());
+    os << formatv("    return b.create<{0}>(loc, {1});\n", op.getCppClassName(),
+                  nameStream.str());
+    os << "  }\n\n";
+  }
+}
+
+static void emitBuilderDef(ArrayRef<Record *> defs, raw_ostream &os) {
+  if (defs.empty())
+    return;
+
+  const Dialect &dialect = Operator(defs.front()).getDialect();
+
+  std::string className =
+      formatv("{0}Builder", dialect.getCppClassName()).str();
+
+  os << "namespace " << dialect.getCppNamespace() << " {\n";
+  os << "class " << className << " {\n";
+  os << "public:\n";
+  os << "  " << className << "(OpBuilder &b, Location loc)";
+  os << "      : b(b), loc(loc) {}\n";
+
+  for (const Record *def : defs) {
+    emitOneBuilderDef(*def, os);
+  }
+
+  os << "private:\n";
+  os << "  ::mlir::OpBuilder &b;\n";
+  os << "  ::mlir::Location loc;\n";
+  os << "};\n";
+  os << "} // end namespace " << dialect.getCppNamespace() << "\n";
+}
+
+static bool emitDialectBuilder(const RecordKeeper &recordKeeper,
+                               raw_ostream &os) {
+  emitSourceFileHeader("DSL-style builder", os);
+
+  // std::vector<Record *> defs = ;
+  emitBuilderDef(getAllDerivedDefinitions(recordKeeper, "Op"), os);
+  return false;
+}
+
 static mlir::GenRegistration
     genOpDecls("gen-op-decls", "Generate op declarations",
                [](const RecordKeeper &records, raw_ostream &os) {
                  return emitOpDecls(records, os);
                });
 
 static mlir::GenRegistration genOpDefs("gen-op-defs", "Generate op definitions",
                                        [](const RecordKeeper &records,
                                           raw_ostream &os) {
                                          return emitOpDefs(records, os);
                                        });
+
+static mlir::GenRegistration genDialectBuilder("gen-dialect-builder",
+                                               "Generate DSL-style builder",
+                                               emitDialectBuilder);