Bump LLVM (#1023)

Fixes after bump:
  - Use LLVM Triple struct
  - Use default memref.copy instead of linalg.copy during bufferization +
    deprecate related test
  - Lower memref.copy to XSMM unary
  - Minor syntax updates

Author: adam-smnk

build_tools/llvm_version.txt

@@ -1 +1 @@
-2b71df5a74cb5bd67f3f34277749dc920fd35105
+0a5847f1c1445bfe55c9f9241c4d6d89609a7dc0

lib/TPP/Conversion/ConvertLinalgToXsmm/ConvertLinalgToXsmm.cpp

@@ -1175,6 +1175,28 @@ struct ConvertCopyOp : public OpRewritePattern<linalg::CopyOp> {
   }
 };
 
+struct ConvertMemRefCopyOp : public OpRewritePattern<memref::CopyOp> {
+  using OpRewritePattern<memref::CopyOp>::OpRewritePattern;
+
+  LogicalResult matchAndRewrite(memref::CopyOp copyOp,
+                                PatternRewriter &rewriter) const override {
+    Value source = copyOp.getSource();
+    Value dest = copyOp.getTarget();
+    auto unaryInfo =
+        xsmm::utils::getUnaryInfo(source, dest, xsmm::UnaryFlags::NONE);
+    if (failed(unaryInfo))
+      return failure();
+    auto flags = rewriter.getArrayAttr(xsmm::UnaryFlagsAttr::get(
+        rewriter.getContext(), xsmm::UnaryFlags::NONE));
+    xsmm::UnaryKindAttr kind = xsmm::UnaryKindAttr::get(
+        rewriter.getContext(), xsmm::UnaryKind::IDENTITY);
+    SmallVector<Value> operands{source, dest};
+    xsmm::utils::replaceOpWithUnary(rewriter, copyOp, operands, *unaryInfo,
+                                    flags, kind);
+    return success();
+  }
+};
+
 } // namespace
 
 void mlir::tpp::populateLinalgToXsmmPatterns(
@@ -1212,7 +1234,7 @@ void mlir::tpp::populateLinalgToXsmmPatterns(
       patterns.add<ConvertTransposeOpToUnaryTranspose>(ctx);
       LLVM_DEBUG(llvm::dbgs() << "[LinalgToXsmm] adding transpose\n");
     } else if (pattern == "copy") {
-      patterns.add<ConvertCopyOp>(ctx);
+      patterns.add<ConvertCopyOp, ConvertMemRefCopyOp>(ctx);
       LLVM_DEBUG(llvm::dbgs() << "[LinalgToXsmm] adding copy\n");
     } else if (pattern == "unary") {
       patterns.add<ConvertGenericToUnary>(ctx);

lib/TPP/GPU/LinalgToXeGPU.cpp

@@ -1102,11 +1102,13 @@ static LogicalResult createDPASKernel(linalg::LinalgOp linalgOp,
       for (int n = 0; n < numTilesN; n++) {
         int cIdx = m * numTilesN + n;
 
-        Value result = rewriter
-                           .create<xegpu::DpasOp>(
-                               loc, dpasResType, dpasVecA.getTile(m, k),
-                               dpasVecB.getTile(k, n), dpasResults[cIdx])
-                           .getResult();
+        Value result =
+            rewriter
+                .create<xegpu::DpasOp>(loc, TypeRange{dpasResType},
+                                       ValueRange{dpasVecA.getTile(m, k),
+                                                  dpasVecB.getTile(k, n),
+                                                  dpasResults[cIdx]})
+                .getResult();
 
         // Update sub-tile partial result.
         dpasResults[cIdx] = result;

lib/TPP/Transforms/Bufferize.cpp

@@ -110,12 +110,6 @@ void DuplicateFill::runOnOperation() {
   });
 }
 
-static LogicalResult defaultMemCpyFn(OpBuilder &builder, Location loc,
-                                     Value from, Value to) {
-  builder.create<linalg::CopyOp>(loc, from, to);
-  return success();
-}
-
 void Bufferize::runOnOperation() {
   ModuleOp moduleOp = getOperation();
 
@@ -128,17 +122,15 @@ void Bufferize::runOnOperation() {
   passManager.addPass(bufferization::createEmptyTensorToAllocTensorPass());
 
   // One-shot.
-  bufferization::OneShotBufferizationOptions buffOpts;
+  bufferization::OneShotBufferizePassOptions buffOpts;
   buffOpts.bufferizeFunctionBoundaries = true;
-  buffOpts.setFunctionBoundaryTypeConversion(
-      bufferization::LayoutMapOption::IdentityLayoutMap);
-  buffOpts.memCpyFn = defaultMemCpyFn;
+  buffOpts.functionBoundaryTypeConversion = "identity-layout-map";
   bool runOnlyAnalysis = this->testAnalysisOnly || this->printConflicts;
   if (runOnlyAnalysis) {
     buffOpts.printConflicts = this->printConflicts;
     buffOpts.testAnalysisOnly = this->testAnalysisOnly;
   }
-  passManager.addPass(bufferization::createOneShotBufferizePass(buffOpts));
+  passManager.addPass(createOneShotBufferizePass(buffOpts));
 
   if (!runOnlyAnalysis) {
     passManager.addPass(bufferization::createDropEquivalentBufferResultsPass());

test/Passes/bufferization.mlir

@@ -186,9 +186,9 @@ func.func @matmuls(%arg0: tensor<32x32xf32>, %arg1: tensor<32x32xf32>) -> tensor
 // CHECK-LABEL: matmuls_1
 func.func @matmuls_1(%arg0: tensor<32x32xf32>, %arg1: tensor<32x32xf32>) -> tensor<32x32xf32> {
   // BUFF-COUNT-3: memref.alloc
-  // BUFF-COUNT-1: linalg.copy
+  // BUFF-COUNT-1: memref.copy
   // BUFFNOTDUP-COUNT-3: memref.alloc
-  // BUFFNOTDUP-COUNT-1: linalg.copy
+  // BUFFNOTDUP-COUNT-1: memref.copy
   // CHECK-COUNT-2: linalg.fill
   %0 = tensor.empty() : tensor<32x32xf32>
   %cst = arith.constant 0.0 : f32

test/Passes/pass-duplicate-fill.mlir

@@ -218,7 +218,7 @@ std::unique_ptr<llvm::Module> lowerToLLVMIR(Operation *module,
     targetOptions.UnsafeFPMath = true;
     targetOptions.AllowFPOpFusion = llvm::FPOpFusion::FPOpFusionMode::Fast;
     targetMachine.reset(target->createTargetMachine(
-        triple, cpuName, "+" + fpuName, targetOptions,
+        llvm::Triple(triple), cpuName, "+" + fpuName, targetOptions,
         /* reloc model */ std::nullopt,
         /* code model */ std::nullopt, codeGenOpt));
     if (!targetMachine) {