[mlir] Intrinsics generator: use TableGen-defined builder function

[ftynse]

Summary

Originally, intrinsics generator for the LLVM dialect has been producing
customized code fragments for the translation of MLIR operations to LLVM IR
intrinsics. LLVM dialect ODS now provides a generalized version of the
translation code, parameterizable with the properties of the operation.
Generate ODS that uses this version of the translation code instead of
generating a new version of it for each intrinsic.

Depends On D74889

[ftynse]

Rebase

[kariddi]

Thanks, nice cleanup!

mlir/include/mlir/Dialect/LLVMIR/LLVMOpBase.td

168

What is the story to convert MLIR operations with multiple return values into intrinsics returning multiple values (structures)?

[kariddi]

mlir/include/mlir/Dialect/LLVMIR/LLVMOpBase.td

168

If everything would pan out just fine for multiple results I suggest renaming "hasResult" with "hasResults"

[ftynse]

mlir/include/mlir/Dialect/LLVMIR/LLVMOpBase.td

168

This should happen within MLIR, on in the translation from MLIR to LLVM IR. Since we want to model LLVM IR closely in the LLVM dialect, intrinsics that return a struct (that consumers will have to "unpack" with extractvalue) are modeled as Ops that return a single value of the corresponding type. Anyone is free to introduce a slightly higher-level operation that has multiple results instead, which would be lowered to this intrinsic. We have support for generating the "unpacking" since day 1 (https://github.com/llvm/llvm-project/commit/6d37a255e2e445671e30b7471283b985cbb34727#diff-bab3c5c46bbcf237dbcfcd8a2a668454R354).

[kariddi]

LGTM

[antiagainst]

Nice clean up!

[nicolasvasilache]

Cool, thanks Alex!

mlir/include/mlir/Dialect/LLVMIR/LLVMOpBase.td

 
 // Base class for LLVM operations. All operations get an "llvm." prefix in
 // their name automatically. LLVM operations have either zero or one result,
 // this class is specialized below for both cases and should not be used
 // directly.
 class LLVM_Op<string mnemonic, list<OpTrait> traits = []> :
     LLVM_OpBase<LLVM_Dialect, mnemonic, traits>;
 
-// Compatibility class for LLVM intrinsic operations.
-class LLVM_IntrOp<string mnemonic, list<OpTrait> traits = []> :
-    LLVM_Op<"intr."#mnemonic, traits>;
-
 // Case of the LLVM enum attribute backed by I64Attr with customized string
 // representation that corresponds to what is visible in the textual IR form.
 // The parameters are as follows:
 //   - `cppSym`: name of the C++ enumerant for this case in MLIR API;
 //   - `irSym`: keyword used in the custom form of MLIR operation;
 //   - `llvmSym`: name of the C++ enumerant for this case in LLVM API.
 // For example, `LLVM_EnumAttrCase<"Weak", "weak", "WeakAnyLinkage">` is usable
 // as `<MlirEnumName>::Weak` in MLIR API, `WeakAnyLinkage` in LLVM API and
llvm::Function *fn = llvm::Intrinsic::getDeclaration(
             ListIntSubst<LLVM_IntrPatterns.operand,
                          overloadedOperands>.lst)>.result # [{
         });
     auto operands = lookupValues(opInst.getOperands());
     }] # !if(hasResult, "$res = ", "") # [{builder.CreateCall(fn, operands);
   }];
 }
 
+// Base class for LLVM intrinsic operations, should not be used directly. Places
+// the intrinsic into the LLVM dialect and prefixes its name with "intr.".
+class LLVM_IntrOp<string mnem, list<int> overloadedResults,
+                  list<int> overloadedOperands, list<OpTrait> traits,
+                  bit hasResult>
+    : LLVM_IntrOpBase<LLVM_Dialect, "intr." # mnem, !subst(".", "_", mnem),
+                      overloadedResults, overloadedOperands, traits, hasResult>;
+
 // Base class for LLVM intrinsic operations returning no results. Places the
 // intrinsic into the LLVM dialect and prefixes its name with "intr.".
 //
 // Sample use: derive an entry from this class and populate the fields.
 //
 //    def LLVM_Name : LLVM_ZeroResultIntrOp<"name", [0], [NoSideEffect]>,
 //                    Arguments<(ins LLVM_Type, LLVM_Type)>;
 //
 // The mnemonic will be prefixed with "llvm.intr.", where the "llvm." part comes
 // from the LLVM dialect. The overloadedOperands list contains the indices of
 // the operands the type of which will be passed in the LLVM IR intrinsic
 // builder. In the example above, the Op has two arguments, but only the first
 // one (as indicated by `[0]`) is necessary to resolve the overloaded intrinsic.
 // The Op has no results.
 class LLVM_ZeroResultIntrOp<string mnem, list<int> overloadedOperands = [],
                             list<OpTrait> traits = []>
-    : LLVM_IntrOpBase<LLVM_Dialect, "intr." # mnem, !subst(".", "_", mnem),
-                      [], overloadedOperands, traits, 0>;
+    : LLVM_IntrOp<mnem, [], overloadedOperands, traits, 0>;
 
 // Base class for LLVM intrinsic operations returning one result. Places the
 // intrinsic into the LLVM dialect and prefixes its name with "intr.". This is
 // similar to LLVM_ZeroResultIntrOp but allows one to define Ops returning one
 // result, called "res". Additionally, the overloadedResults list should contain
 // "0" if the result must be used to resolve overloaded intrinsics, or remain
 // empty otherwise.
 class LLVM_OneResultIntrOp<string mnem, list<int> overloadedResults = [],
                            list<int> overloadedOperands = [],
                            list<OpTrait> traits = []>
-    : LLVM_IntrOpBase<LLVM_Dialect, "intr." # mnem, !subst(".", "_", mnem),
-                      overloadedResults, overloadedOperands, traits, 1>;
+    : LLVM_IntrOp<mnem, overloadedResults, overloadedOperands, traits, 1>;
 
 // LLVM vector reduction over a single vector.
 class LLVM_VectorReduction<string mnem>
     : LLVM_OneResultIntrOp<"experimental.vector.reduce." # mnem, [], [0], []>,
       Arguments<(ins LLVM_Type)>;
 
 // LLVM vector reduction over a single vector, with an initial value.
 class LLVM_VectorReductionV2<string mnem>
     : LLVM_OneResultIntrOp<"experimental.vector.reduce.v2." # mnem,
                            [0], [1], []>,
       Arguments<(ins LLVM_Type, LLVM_Type)>;
 
 #endif  // LLVMIR_OP_BASE

mlir/test/mlir-tblgen/llvm-intrinsics.td

 //
 // RUN: cat %S/../../../llvm/include/llvm/IR/Intrinsics.td \
 // RUN: | grep -v "llvm/IR/Intrinsics" \
 // RUN: | mlir-tblgen -gen-llvmir-intrinsics -I %S/../../../llvm/include/ --llvmir-intrinsics-filter=ptrmask \
 // RUN: | FileCheck %s
 
 // CHECK-LABEL: def LLVM_ptrmask
 // CHECK: LLVM_IntrOp<"ptrmask
-// CHECK: Arguments<(ins
-// CHECK: Results<(outs
-// CHECK: llvm::Function *fn = llvm::Intrinsic::getDeclaration(
-// CHECK:        module, llvm::Intrinsic::ptrmask, {
-// CHECK:        opInst.getResult(0).getType().cast<LLVM::LLVMType>().getUnderlyingType(),
-// CHECK:        opInst.getOperand(0).getType().cast<LLVM::LLVMType>().getUnderlyingType(),
-// CHECK:        opInst.getOperand(1).getType().cast<LLVM::LLVMType>().getUnderlyingType(),
-// CHECK: });
-// CHECK:        lookupValues(opInst.getOperands());
+// The result of this intrinsic result is overloadable.
+// CHECK: [0]
+// Both its operands are overloadable.
+// CHECK: [0, 1]
+// It has no additional traits.
+// CHECK: []
+// It has a result.
+// CHECK: 1>
+// CHECK: Arguments<(ins LLVM_Type, LLVM_Type
 
 //---------------------------------------------------------------------------//
 
 // This checks that the ODS we produce can be consumed by MLIR tablegen. We only
 // make sure the entire process does not fail and produces some C++. The shape
 // of this C++ code is tested by ODS tests.
 
 // RUN: cat %S/../../../llvm/include/llvm/IR/Intrinsics.td \

mlir/tools/mlir-tblgen/LLVMIRIntrinsicGen.cpp

private:
   const char *fieldOperands = "ParamTypes";
   const char *fieldResults = "RetTypes";
   const char *fieldTraits = "IntrProperties";
 
   const llvm::Record &record;
 };
 } // namespace
 
-/// Emits C++ code constructing an LLVM IR intrinsic given the generated MLIR
-/// operation.  In LLVM IR, intrinsics are constructed as function calls.
-static void emitBuilder(const LLVMIntrinsic &intr, llvm::raw_ostream &os) {
-  auto overloadedRes = intr.getOverloadableResultsIdxs();
-  auto overloadedOps = intr.getOverloadableOperandsIdxs();
-  os << "    llvm::Module *module = builder.GetInsertBlock()->getModule();\n";
-  os << "    llvm::Function *fn = llvm::Intrinsic::getDeclaration(\n";
-  os << "        module, llvm::Intrinsic::" << intr.getProperRecordName()
-     << ", {";
-  for (unsigned idx : overloadedRes.set_bits()) {
-    os << "\n        opInst.getResult(" << idx << ").getType()"
-       << ".cast<LLVM::LLVMType>().getUnderlyingType(),";
-  }
-  for (unsigned idx : overloadedOps.set_bits()) {
-    os << "\n        opInst.getOperand(" << idx << ").getType()"
-       << ".cast<LLVM::LLVMType>().getUnderlyingType(),";
-  }
-  if (overloadedRes.any() || overloadedOps.any())
-    os << "\n  ";
-  os << "});\n";
-  os << "    auto operands =\n";
-  os << "        lookupValues(opInst.getOperands());\n";
-  os << "  " << (intr.getNumResults() > 0 ? "$res = " : "")
-     << "builder.CreateCall(fn, operands);\n";
-  os << "  ";
+/// Prints the elements in "range" separated by commas and surrounded by "[]".
+template <typename Range>
+void printBracketedRange(const Range &range, llvm::raw_ostream &os) {
+  os << '[';
+  mlir::interleaveComma(range, os);
+  os << ']';
 }
 
 /// Emits ODS (TableGen-based) code for `record` representing an LLVM intrinsic.
 /// Returns true on error, false on success.
 static bool emitIntrinsic(const llvm::Record &record, llvm::raw_ostream &os) {
   LLVMIntrinsic intr(record);
 
   // Prepare strings for traits, if any.
   llvm::SmallVector<llvm::StringRef, 2> traits;
   if (intr.isCommutative())
     traits.push_back("Commutative");
   if (!intr.hasSideEffects())
     traits.push_back("NoSideEffect");
 
   // Prepare strings for operands.
   llvm::SmallVector<llvm::StringRef, 8> operands(intr.getNumOperands(),
                                                  "LLVM_Type");
 
   // Emit the definition.
   os << "def LLVM_" << intr.getProperRecordName() << " : " << opBaseClass
-     << "<\"" << intr.getOperationName() << "\", [";
-  mlir::interleaveComma(traits, os);
-  os << "]>, Arguments<(ins" << (operands.empty() ? "" : " ");
+     << "<\"" << intr.getOperationName() << "\", ";
+  printBracketedRange(intr.getOverloadableResultsIdxs().set_bits(), os);
+  os << ", ";
+  printBracketedRange(intr.getOverloadableOperandsIdxs().set_bits(), os);
+  os << ", ";
+  printBracketedRange(traits, os);
+  os << ", " << (intr.getNumResults() == 0 ? 0 : 1) << ">, Arguments<(ins"
+     << (operands.empty() ? "" : " ");
   mlir::interleaveComma(operands, os);
-  os << ")>, Results<(outs"
-     << (intr.getNumResults() == 0 ? "" : " LLVM_Type:$res") << ")> {\n"
-     << "  let llvmBuilder = [{\n";
-  emitBuilder(intr, os);
-  os << "}];\n";
-  os << "}\n\n";
+  os << ")>;\n\n";
 
   return false;
 }
 
 /// Traverses the list of TableGen definitions derived from the "Intrinsic"
 /// class and generates MLIR ODS definitions for those intrinsics that have
 /// the name matching the filter.
 static bool emitIntrinsics(const llvm::RecordKeeper &records,