Integrate LLVM at llvm/llvm-project@42a8ff877d47; migrate op-creation API (#2870)

In addition to bumping the LLVM version, this PR updates call sites of
an old op-creation API which is marked as deprecated in the latest LLVM
version.

The old API was of the form `rewriter.create<OpType>(...)`, now replaced
with `OpType::create(rewriter, ...)`.

Author: mrguenther

WORKSPACE.bazel

@@ -17,9 +17,9 @@ workspace(name = "stablehlo")
 
 load("@bazel_tools//tools/build_defs/repo:http.bzl", "http_archive")
 
-LLVM_COMMIT = "32de3b9ef9e7e8debc14416e968456ca13b48bea"
+LLVM_COMMIT = "42a8ff877d47131ecb1280a1cc7e5e3c3bca6952"
 
-LLVM_SHA256 = "e048b05e1fb9366e224ea3c06f8473714114039bfad00e81db4ecb6409f23efa"
+LLVM_SHA256 = "f768c5c3b987f68318b8ab3dd4530e54988dfe7d6bfb9b7c9c96acf503367d50"
 
 http_archive(
     name = "llvm-raw",

build_tools/llvm_version.txt

@@ -1 +1 @@
-32de3b9ef9e7e8debc14416e968456ca13b48bea
+42a8ff877d47131ecb1280a1cc7e5e3c3bca6952

examples/c++/ExampleAdd.cpp

@@ -69,9 +69,9 @@ int main() {
 
   llvm::SmallVector<mlir::NamedAttribute, 10> attributes;
   mlir::Operation* op =
-      block_builder.create<mlir::stablehlo::AddOp>(loc, arguments, attributes)
+      mlir::stablehlo::AddOp::create(block_builder, loc, arguments, attributes)
           .getOperation();
-  block_builder.create<mlir::func::ReturnOp>(loc, op->getResult(0));
+  mlir::func::ReturnOp::create(block_builder, loc, op->getResult(0));
 
   /** verify and dump the module **/
   assert(mlir::succeeded(mlir::verify(module.get())));

stablehlo/conversions/linalg/tests/miscellaneous.mlir

@@ -768,7 +768,7 @@ func.func @map_compare(%arg0: tensor<?xcomplex<f32>>,
 // CHECK-PRIMITIVE: %[[MAP:.+]] = linalg.map
 // CHECK-PRIMITIVE-SAME: ins(%[[ARG0]], %[[ARG1]]
 // CHECK-PRIMITIVE-SAME: outs(%[[INIT]] : tensor<?xi1>)
-// CHECK-PRIMITIVE-NEXT: (%[[A:.+]]: complex<f32>, %[[B:.+]]: complex<f32>) {
+// CHECK-PRIMITIVE-NEXT: (%[[A:.+]]: complex<f32>, %[[B:.+]]: complex<f32>, %{{.+}}: i1) {
 // CHECK-PRIMITIVE: %[[RE1:.+]] = complex.re %[[A]] : complex<f32>
 // CHECK-PRIMITIVE: %[[RE2:.+]] = complex.re %[[B]] : complex<f32>
 // CHECK-PRIMITIVE: %[[CMP:.+]] = arith.cmpf oeq, %[[RE1]], %[[RE2]] : f32

stablehlo/conversions/linalg/tests/pointwise.mlir

@@ -714,7 +714,7 @@ func.func @float_cmp_totalorder(%lhs: tensor<2x2xbf16>,
 // CHECK-PRIMITIVE: linalg.map
 // CHECK-PRIMITIVE-SAME: ins(
 // CHECK-PRIMITIVE-SAME: outs(
-// CHECK-PRIMITIVE-NEXT: (%[[LHS_IN:[a-zA-Z0-9]*]]: bf16, %[[RHS_IN:.*]]: bf16) {
+// CHECK-PRIMITIVE-NEXT: (%[[LHS_IN:[a-zA-Z0-9]*]]: bf16, %[[RHS_IN:.*]]: bf16, %[[RESULT_OUT:.*]]: i1) {
 // CHECK-PRIMITIVE-NEXT:   %[[LHS_INT:.*]] = arith.bitcast %[[LHS_IN]] : bf16 to i16
 // CHECK-PRIMITIVE-NEXT:   %[[LHS_CMP:.*]] = arith.cmpi slt, %[[LHS_INT]], %[[C0]] : i16
 // CHECK-PRIMITIVE-NEXT:   %[[LHS_SUB:.*]] = arith.subi %[[C32767]], %[[LHS_INT]] : i16
@@ -937,7 +937,7 @@ func.func @select_scalar_pred_dyn(%pred : tensor<i1>, %lhs: tensor<2x?xf32>, %rh
 // CHECK-PRIMITIVE-SAME:   ins(%[[LHS]], %[[RHS]] : tensor<2x?xf32>, tensor<2x?xf32>)
 // CHECK-PRIMITIVE-SAME:   outs(%[[DST]] : tensor<2x?xf32>)
 // CHECK-PRIMITIVE-SAME:   {someattr}
-// CHECK-PRIMITIVE:      (%[[LHS_:.*]]: f32, %[[RHS_:.*]]: f32) {
+// CHECK-PRIMITIVE:      (%[[LHS_:.*]]: f32, %[[RHS_:.*]]: f32, %[[RESULT_OUT:.*]]: f32) {
 // CHECK-PRIMITIVE:        %[[RES:.*]] = arith.select %[[PRED_ELEM]], %[[LHS_]], %[[RHS_]] : f32
 // CHECK-PRIMITIVE:        linalg.yield %[[RES]]
 
@@ -978,7 +978,7 @@ func.func @select_scalar_pred_static(%lhs: tensor<2x?xf32>, %rhs: tensor<2x?xf32
 // CHECK-PRIMITIVE-SAME:   ins(%[[LHS]], %[[RHS]] : tensor<2x?xf32>, tensor<2x?xf32>)
 // CHECK-PRIMITIVE-SAME:   outs(%[[DST]] : tensor<2x?xf32>)
 // CHECK-PRIMITIVE-SAME:   {someattr}
-// CHECK-PRIMITIVE:      (%[[LHS_:.*]]: f32, %[[RHS_:.*]]: f32) {
+// CHECK-PRIMITIVE:      (%[[LHS_:.*]]: f32, %[[RHS_:.*]]: f32, %[[RESULT_OUT:.*]]: f32) {
 // CHECK-PRIMITIVE:        linalg.yield %[[LHS_]]
 
 // -----
@@ -1416,7 +1416,7 @@ func.func @clamp_static(%lb : tensor<4xf32>, %x : tensor<4xf32>, %ub : tensor<4x
 
 // CHECK-PRIMITIVE: %[[INIT:.*]] = tensor.empty
 // CHECK-PRIMITIVE: %[[RESULT:.*]] = linalg.map ins(%[[LB]], %[[X]], %[[UB]] : tensor<4xf32>, tensor<4xf32>, tensor<4xf32>) outs(%[[INIT]] : tensor<4xf32>)
-// CHECK-PRIMITIVE: (%[[SCALAR_LB:.*]]: f32, %[[SCALAR_X:.*]]: f32, %[[SCALAR_UB:.*]]: f32)
+// CHECK-PRIMITIVE: (%[[SCALAR_LB:.*]]: f32, %[[SCALAR_X:.*]]: f32, %[[SCALAR_UB:.*]]: f32, %[[RESULT_OUT:.*]]: f32)
 // CHECK-PRIMITIVE:   %[[MAX:.*]] = arith.maximumf %[[SCALAR_LB]], %[[SCALAR_X]] : f32
 // CHECK-PRIMITIVE:   %[[MIN:.*]] = arith.minimumf %[[MAX]], %[[SCALAR_UB]] : f32
 // CHECK-PRIMITIVE:   linalg.yield %[[MIN]]
@@ -1478,7 +1478,7 @@ func.func @clamp_scalar(%lb : tensor<f32>, %x : tensor<?xf32>, %ub : tensor<f32>
 // CHECK-PRIMITIVE-DAG: %[[SCALAR_LB:.*]] = tensor.extract %[[LB]]
 // CHECK-PRIMITIVE-DAG: %[[SCALAR_UB:.*]] = tensor.extract %[[UB]]
 // CHECK-PRIMITIVE: %[[RESULT:.*]] = linalg.map ins(%[[X]] : tensor<?xf32>) outs(%[[INIT]] : tensor<?xf32>)
-// CHECK-PRIMITIVE: (%[[SCALAR_X:.*]]: f32)
+// CHECK-PRIMITIVE: (%[[SCALAR_X:.*]]: f32, %[[RESULT_OUT:.*]]: f32)
 // CHECK-PRIMITIVE:   %[[MAX:.*]] = arith.maximumf %[[SCALAR_LB]], %[[SCALAR_X]] : f32
 // CHECK-PRIMITIVE:   %[[MIN:.*]] = arith.minimumf %[[MAX]], %[[SCALAR_UB]] : f32
 // CHECK-PRIMITIVE:   linalg.yield %[[MIN]]
@@ -1554,7 +1554,7 @@ func.func @integer_not(%arg: tensor<2x2xi32>) -> tensor<2x2xi32> {
   // CHECK:   linalg.yield %[[V_NOT]] : i32
   // CHECK-PRIMITIVE: %[[CST_N1:.+]] = arith.constant -1 : i32
   // CHECK-PRIMITIVE: linalg.map
-  // CHECK-PRIMITIVE:   (%[[IN:.+]]: i32)
+  // CHECK-PRIMITIVE:   (%[[IN:.+]]: i32, %[[RESULT_OUT:.+]]: i32)
   // CHECK-PRIMITIVE:   %[[V_NOT:.+]] = arith.xori %[[IN]], %[[CST_N1]] : i32
   // CHECK-PRIMITIVE:   linalg.yield %[[V_NOT]] : i32
   %0 = "stablehlo.not"(%arg) : (tensor<2x2xi32>) -> tensor<2x2xi32>

stablehlo/conversions/linalg/transforms/LegalizeToLinalgUtils.cpp

@@ -105,7 +105,7 @@ Value getEmptyTensorFor(OpBuilder& b, Location loc, ShapedType resultType,
       if (en.value() != ShapedType::kDynamic) continue;
       sizes.push_back(tensor::ExtractOp::create(
           b, loc, reifiedShapes[0],
-          ValueRange{b.create<arith::ConstantIndexOp>(loc, en.index())}));
+          ValueRange{arith::ConstantIndexOp::create(b, loc, en.index())}));
     }
   }
   return isSparse ? getEmptySparseTensor(b, loc, resultType, sizes)
@@ -149,7 +149,7 @@ Value preSparsify(Operation* op, llvm::SmallVector<Value, 2>& values, Type rtp,
         !sparse_tensor::getSparseTensorEncoding(op->getOperand(0).getType()))
       return Value();
     Location loc = op->getLoc();
-    auto semiring = b->create<sparse_tensor::UnaryOp>(loc, rtp, values[0]);
+    auto semiring = sparse_tensor::UnaryOp::create(*b, loc, rtp, values[0]);
     Type itp = values[0].getType();
     Block* present = b->createBlock(&semiring.getPresentRegion(), {}, itp, loc);
     b->setInsertionPointToStart(&semiring.getPresentRegion().front());
@@ -161,7 +161,7 @@ Value preSparsify(Operation* op, llvm::SmallVector<Value, 2>& values, Type rtp,
 
 Value postSparsify(Operation* op, Value semiring, Value result, OpBuilder* b) {
   if (semiring) {
-    b->create<sparse_tensor::YieldOp>(op->getLoc(), result);
+    sparse_tensor::YieldOp::create(*b, op->getLoc(), result);
     b->setInsertionPointAfter(semiring.getDefiningOp());
     return semiring;
   }