Update llvm, 2025 Q3

.dep-versions

@@ -2,9 +2,9 @@
 # To update JAX version alongside compatible dependency tags, run the following script:
 # python3 .github/workflows/set_dep_versions.py {JAX_version}
 jax=0.6.2
-mhlo=617a9361d186199480c080c9e8c474a5e30c22d1
-llvm=179d30f8c3fddd3c85056fd2b8e877a4a8513158
-enzyme=v0.0.180
+mhlo=1dd2e71331014ae0373f6bf900ce6be393357190
+llvm=f8cb7987c64dcffb72414a40560055cb717dbf74
+enzyme=v0.0.186
 
 # Always remove custom PL/LQ versions before release.
 

mlir/Makefile

@@ -97,6 +97,11 @@ mhlo:
 	@if cd mlir-hlo; git apply --check $(MK_DIR)/patches/mhlo-add-back-necessary-passes.patch; then \
 		git apply $(MK_DIR)/patches/mhlo-add-back-necessary-passes.patch; \
 	fi
+
+	# Patch a MHLO bug with std::sort
+	@if cd mlir-hlo; git apply --check $(MK_DIR)/patches/mhlo-rename-sort.patch; then \
+		git apply $(MK_DIR)/patches/mhlo-rename-sort.patch; \
+	fi
 	cmake -G Ninja -S mlir-hlo -B $(MHLO_BUILD_DIR) \
 		-DCMAKE_BUILD_TYPE=$(BUILD_TYPE) \
 		-DLLVM_ENABLE_ASSERTIONS=ON \

mlir/include/Catalyst/Transforms/AsyncUtils.h

@@ -63,13 +63,13 @@ bool hasAbortInBlock(Block *block);
 bool hasPutsInBlock(Block *block);
 
 // Helper function for creating function declarations
-LLVM::LLVMFuncOp lookupOrCreatePersonality(ModuleOp moduleOp);
-LLVM::LLVMFuncOp lookupOrCreateAbort(ModuleOp moduleOp);
-LLVM::LLVMFuncOp lookupOrCreateMlirAsyncRuntimeSetValueError(ModuleOp moduleOp);
-LLVM::LLVMFuncOp lookupOrCreateMlirAsyncRuntimeSetTokenError(ModuleOp moduleOp);
-LLVM::LLVMFuncOp lookupOrCreateUnrecoverableError(ModuleOp moduleOp);
-LLVM::LLVMFuncOp lookupOrCreateAwaitTokenName(ModuleOp);
-LLVM::LLVMFuncOp lookupOrCreateAwaitValueName(ModuleOp);
-LLVM::LLVMFuncOp lookupOrCreateDropRef(ModuleOp);
+LLVM::LLVMFuncOp lookupOrCreatePersonality(OpBuilder &b, ModuleOp moduleOp);
+LLVM::LLVMFuncOp lookupOrCreateAbort(OpBuilder &b, ModuleOp moduleOp);
+LLVM::LLVMFuncOp lookupOrCreateMlirAsyncRuntimeSetValueError(OpBuilder &b, ModuleOp moduleOp);
+LLVM::LLVMFuncOp lookupOrCreateMlirAsyncRuntimeSetTokenError(OpBuilder &b, ModuleOp moduleOp);
+LLVM::LLVMFuncOp lookupOrCreateUnrecoverableError(OpBuilder &b, ModuleOp moduleOp);
+LLVM::LLVMFuncOp lookupOrCreateAwaitTokenName(OpBuilder &b, ModuleOp);
+LLVM::LLVMFuncOp lookupOrCreateAwaitValueName(OpBuilder &b, ModuleOp);
+LLVM::LLVMFuncOp lookupOrCreateDropRef(OpBuilder &b, ModuleOp);
 
 }; // namespace AsyncUtils

mlir/lib/Catalyst/Transforms/AsyncUtils.cpp

@@ -128,81 +128,84 @@ LLVM::LLVMFuncOp AsyncUtils::getCaller(LLVM::CallOp callOp)
     return callOp->getParentOfType<LLVM::LLVMFuncOp>();
 }
 
-LLVM::LLVMFuncOp AsyncUtils::lookupOrCreatePersonality(ModuleOp moduleOp)
+LLVM::LLVMFuncOp AsyncUtils::lookupOrCreatePersonality(OpBuilder &b, ModuleOp moduleOp)
 {
     MLIRContext *ctx = moduleOp.getContext();
     auto i32Ty = IntegerType::get(ctx, 32);
     bool isVarArg = true;
-    return mlir::LLVM::lookupOrCreateFn(moduleOp, AsyncUtilsConstants::personalityName, {}, i32Ty,
-                                        isVarArg)
+    return mlir::LLVM::lookupOrCreateFn(b, moduleOp, AsyncUtilsConstants::personalityName, {},
+                                        i32Ty, isVarArg)
         .value();
 }
 
-LLVM::LLVMFuncOp AsyncUtils::lookupOrCreateAbort(ModuleOp moduleOp)
+LLVM::LLVMFuncOp AsyncUtils::lookupOrCreateAbort(OpBuilder &b, ModuleOp moduleOp)
 {
     MLIRContext *ctx = moduleOp.getContext();
     auto voidTy = LLVM::LLVMVoidType::get(ctx);
-    return mlir::LLVM::lookupOrCreateFn(moduleOp, AsyncUtilsConstants::abortName, {}, voidTy)
+    return mlir::LLVM::lookupOrCreateFn(b, moduleOp, AsyncUtilsConstants::abortName, {}, voidTy)
         .value();
 }
 
-LLVM::LLVMFuncOp AsyncUtils::lookupOrCreateAwaitTokenName(ModuleOp moduleOp)
+LLVM::LLVMFuncOp AsyncUtils::lookupOrCreateAwaitTokenName(OpBuilder &b, ModuleOp moduleOp)
 {
     MLIRContext *ctx = moduleOp.getContext();
     Type ptrTy = LLVM::LLVMPointerType::get(moduleOp.getContext());
     auto voidTy = LLVM::LLVMVoidType::get(ctx);
     return mlir::LLVM::lookupOrCreateFn(
-               moduleOp, AsyncUtilsConstants::mlirAsyncRuntimeAwaitTokenName, {ptrTy}, voidTy)
+               b, moduleOp, AsyncUtilsConstants::mlirAsyncRuntimeAwaitTokenName, {ptrTy}, voidTy)
         .value();
 }
 
-LLVM::LLVMFuncOp AsyncUtils::lookupOrCreateAwaitValueName(ModuleOp moduleOp)
+LLVM::LLVMFuncOp AsyncUtils::lookupOrCreateAwaitValueName(OpBuilder &b, ModuleOp moduleOp)
 {
     MLIRContext *ctx = moduleOp.getContext();
     Type ptrTy = LLVM::LLVMPointerType::get(moduleOp.getContext());
     auto voidTy = LLVM::LLVMVoidType::get(ctx);
     return mlir::LLVM::lookupOrCreateFn(
-               moduleOp, AsyncUtilsConstants::mlirAsyncRuntimeAwaitValueName, {ptrTy}, voidTy)
+               b, moduleOp, AsyncUtilsConstants::mlirAsyncRuntimeAwaitValueName, {ptrTy}, voidTy)
         .value();
 }
 
-LLVM::LLVMFuncOp AsyncUtils::lookupOrCreateDropRef(ModuleOp moduleOp)
+LLVM::LLVMFuncOp AsyncUtils::lookupOrCreateDropRef(OpBuilder &b, ModuleOp moduleOp)
 {
     MLIRContext *ctx = moduleOp.getContext();
     Type ptrTy = LLVM::LLVMPointerType::get(moduleOp.getContext());
     Type llvmInt64Type = IntegerType::get(moduleOp.getContext(), 64);
     auto voidTy = LLVM::LLVMVoidType::get(ctx);
-    return mlir::LLVM::lookupOrCreateFn(moduleOp, AsyncUtilsConstants::mlirAsyncRuntimeDropRefName,
+    return mlir::LLVM::lookupOrCreateFn(b, moduleOp,
+                                        AsyncUtilsConstants::mlirAsyncRuntimeDropRefName,
                                         {ptrTy, llvmInt64Type}, voidTy)
         .value();
 }
 
-LLVM::LLVMFuncOp AsyncUtils::lookupOrCreateMlirAsyncRuntimeSetValueError(ModuleOp moduleOp)
+LLVM::LLVMFuncOp AsyncUtils::lookupOrCreateMlirAsyncRuntimeSetValueError(OpBuilder &b,
+                                                                         ModuleOp moduleOp)
 {
     MLIRContext *ctx = moduleOp.getContext();
     Type ptrTy = LLVM::LLVMPointerType::get(moduleOp.getContext());
     auto voidTy = LLVM::LLVMVoidType::get(ctx);
     return mlir::LLVM::lookupOrCreateFn(
-               moduleOp, AsyncUtilsConstants::mlirAsyncRuntimeSetValueErrorName, {ptrTy}, voidTy)
+               b, moduleOp, AsyncUtilsConstants::mlirAsyncRuntimeSetValueErrorName, {ptrTy}, voidTy)
         .value();
 }
 
-LLVM::LLVMFuncOp AsyncUtils::lookupOrCreateMlirAsyncRuntimeSetTokenError(ModuleOp moduleOp)
+LLVM::LLVMFuncOp AsyncUtils::lookupOrCreateMlirAsyncRuntimeSetTokenError(OpBuilder &b,
+                                                                         ModuleOp moduleOp)
 {
     MLIRContext *ctx = moduleOp.getContext();
     Type ptrTy = LLVM::LLVMPointerType::get(moduleOp.getContext());
     auto voidTy = LLVM::LLVMVoidType::get(ctx);
     return mlir::LLVM::lookupOrCreateFn(
-               moduleOp, AsyncUtilsConstants::mlirAsyncRuntimeSetTokenErrorName, {ptrTy}, voidTy)
+               b, moduleOp, AsyncUtilsConstants::mlirAsyncRuntimeSetTokenErrorName, {ptrTy}, voidTy)
         .value();
 }
 
-LLVM::LLVMFuncOp AsyncUtils::lookupOrCreateUnrecoverableError(ModuleOp moduleOp)
+LLVM::LLVMFuncOp AsyncUtils::lookupOrCreateUnrecoverableError(OpBuilder &b, ModuleOp moduleOp)
 {
     MLIRContext *ctx = moduleOp.getContext();
     auto voidTy = LLVM::LLVMVoidType::get(ctx);
-    return mlir::LLVM::lookupOrCreateFn(moduleOp, AsyncUtilsConstants::unrecoverableErrorName, {},
-                                        voidTy)
+    return mlir::LLVM::lookupOrCreateFn(b, moduleOp, AsyncUtilsConstants::unrecoverableErrorName,
+                                        {}, voidTy)
         .value();
 }
 

mlir/lib/Catalyst/Transforms/BufferizableOpInterfaceImpl.cpp

@@ -169,7 +169,7 @@ struct CustomCallOpInterface
             MemRefType memrefType =
                 MemRefType::get(tensorType.getShape(), tensorType.getElementType());
             auto newBuffer =
-                rewriter.create<bufferization::ToMemrefOp>(op->getLoc(), memrefType, *tensorAlloc);
+                rewriter.create<bufferization::ToBufferOp>(op->getLoc(), memrefType, *tensorAlloc);
             bufferArgs.push_back(newBuffer);
         }
 
@@ -314,8 +314,8 @@ struct CallbackCallOpInterface
             auto shape = tensorTy.getShape();
             auto elementTy = tensorTy.getElementType();
             auto memrefType = MemRefType::get(shape, elementTy);
-            auto toMemrefOp = rewriter.create<bufferization::ToMemrefOp>(loc, memrefType, tensor);
-            auto memref = toMemrefOp.getResult();
+            auto toBufferOp = rewriter.create<bufferization::ToBufferOp>(loc, memrefType, tensor);
+            auto memref = toBufferOp.getResult();
             outmemrefs.push_back(memref);
             newInputs.push_back(memref);
         }

mlir/lib/Catalyst/Transforms/DetectQNodes.cpp

@@ -133,7 +133,7 @@ LogicalResult AddExceptionHandlingTransform::matchAndRewrite(LLVM::CallOp callOp
     auto moduleOp = callOp->getParentOfType<ModuleOp>();
     // Here, we are adding a reference to the personality declaration.
     // From the documentation: https://llvm.org/docs/ExceptionHandling.html#exception-tables
-    auto personality = AsyncUtils::lookupOrCreatePersonality(moduleOp);
+    auto personality = AsyncUtils::lookupOrCreatePersonality(rewriter, moduleOp);
 
     // We annotate the body of the function containing the callop to have a reference
     // to the personality.
@@ -294,7 +294,7 @@ RemoveAbortAndPutsInsertCallTransform::matchAndRewrite(LLVM::CallOp callOp,
     // Here, we are declaring an external function which is available in the Catalyst runtime.
     //     llvm.func @__catalyst__host__rt__unrecoverable_error()
     auto moduleOp = callOp->getParentOfType<ModuleOp>();
-    auto unrecoverableError = AsyncUtils::lookupOrCreateUnrecoverableError(moduleOp);
+    auto unrecoverableError = AsyncUtils::lookupOrCreateUnrecoverableError(rewriter, moduleOp);
 
     auto callee = maybeCallee.value();
     rewriter.modifyOpInPlace(callee, [&] { callee.setLinkage(LLVM::Linkage::Internal); });
@@ -516,8 +516,8 @@ LogicalResult LivenessAnalysisDropRef::matchAndRewrite(LLVM::CallOp sink,
     //     llvm.func @mlirAsyncRuntimeAwaitValue(!llvm.ptr)
     //     llvm.func @mlirAsyncRuntimeAwaitToken(!llvm.ptr)
     //     llvm.func @mlirAsyncRuntimeDropRef(!llvm.ptr, i64)
-    auto awaitFnDecl = AsyncUtils::lookupOrCreateAwaitTokenName(moduleOp);
-    auto dropRefFnDecl = AsyncUtils::lookupOrCreateDropRef(moduleOp);
+    auto awaitFnDecl = AsyncUtils::lookupOrCreateAwaitTokenName(rewriter, moduleOp);
+    auto dropRefFnDecl = AsyncUtils::lookupOrCreateDropRef(rewriter, moduleOp);
 
     Type llvmInt64Type = IntegerType::get(sink->getContext(), 64);
     auto one = rewriter.getIntegerAttr(llvmInt64Type, 1);
@@ -871,9 +871,9 @@ void insertErrorCalls(std::vector<Value> tokens, std::vector<Value> values, Bloc
     auto moduleOp = landingPad->getParentOfType<ModuleOp>();
 
     LLVM::LLVMFuncOp setTokenError =
-        AsyncUtils::lookupOrCreateMlirAsyncRuntimeSetTokenError(moduleOp);
+        AsyncUtils::lookupOrCreateMlirAsyncRuntimeSetTokenError(rewriter, moduleOp);
     LLVM::LLVMFuncOp setValueError =
-        AsyncUtils::lookupOrCreateMlirAsyncRuntimeSetValueError(moduleOp);
+        AsyncUtils::lookupOrCreateMlirAsyncRuntimeSetValueError(rewriter, moduleOp);
     for (auto token : tokens) {
         insertCallToMlirAsyncRuntimeErrorFunction(token, setTokenError, failBlock, rewriter);
     }
@@ -918,11 +918,8 @@ struct AddExceptionHandlingPass : impl::AddExceptionHandlingPassBase<AddExceptio
         patterns1.add<DetectCallsInAsyncRegionsTransform>(context);
 
         GreedyRewriteConfig config;
-        config.strictMode = GreedyRewriteStrictness::ExistingOps;
-        config.enableRegionSimplification = mlir::GreedySimplifyRegionLevel::Disabled;
-        // TODO: Update to the following lines the next time we update llvm
-        // config.setStrictness(GreedyRewriteStrictness::ExistingOps);
-        // config.setRegionSimplificationLevel(mlir::GreedySimplifyRegionLevel::Disabled);
+        config.setStrictness(GreedyRewriteStrictness::ExistingOps);
+        config.setRegionSimplificationLevel(mlir::GreedySimplifyRegionLevel::Disabled);
 
         if (failed(applyPatternsGreedily(getOperation(), std::move(patterns1), config))) {
             signalPassFailure();

mlir/lib/Catalyst/Transforms/GEPInboundsPatterns.cpp

@@ -29,11 +29,12 @@ struct GEPOpRewritePattern : public mlir::OpRewritePattern<LLVM::GEPOp> {
                                         mlir::PatternRewriter &rewriter) const override
     {
         auto defOp = op.getBase().getDefiningOp();
-        if (op.getInbounds() || (defOp && isa<LLVM::ZeroOp>(defOp))) {
+        if (op.getNoWrapFlags() == LLVM::GEPNoWrapFlags::inbounds() ||
+            (defOp && isa<LLVM::ZeroOp>(defOp))) {
             return failure();
         }
         rewriter.startOpModification(op);
-        op.setInbounds(true);
+        op.setNoWrapFlags(LLVM::GEPNoWrapFlags::inbounds());
         rewriter.finalizeOpModification(op);
         return success();
     }

mlir/lib/Catalyst/Transforms/InlineNestedModules.cpp

@@ -380,11 +380,8 @@ struct AnnotateWithFullyQualifiedNamePass
     {
         MLIRContext *context = &getContext();
         GreedyRewriteConfig config;
-        config.strictMode = GreedyRewriteStrictness::ExistingOps;
-        config.enableRegionSimplification = mlir::GreedySimplifyRegionLevel::Disabled;
-        // TODO: Update to the following lines the next time we update llvm
-        // config.setStrictness(GreedyRewriteStrictness::ExistingOps);
-        // config.setRegionSimplificationLevel(mlir::GreedySimplifyRegionLevel::Disabled);
+        config.setStrictness(GreedyRewriteStrictness::ExistingOps);
+        config.setRegionSimplificationLevel(mlir::GreedySimplifyRegionLevel::Disabled);
 
         RewritePatternSet annotate(context);
         auto root = getOperation();
@@ -409,11 +406,8 @@ struct InlineNestedSymbolTablePass : PassWrapper<InlineNestedSymbolTablePass, Op
         MLIRContext *context = &getContext();
 
         GreedyRewriteConfig config;
-        config.strictMode = GreedyRewriteStrictness::ExistingOps;
-        config.enableRegionSimplification = mlir::GreedySimplifyRegionLevel::Disabled;
-        // TODO: Update to the following lines the next time we update llvm
-        // config.setStrictness(GreedyRewriteStrictness::ExistingOps);
-        // config.setRegionSimplificationLevel(mlir::GreedySimplifyRegionLevel::Disabled);
+        config.setStrictness(GreedyRewriteStrictness::ExistingOps);
+        config.setRegionSimplificationLevel(mlir::GreedySimplifyRegionLevel::Disabled);
         RewritePatternSet renameFunctions(context);
 
         // Get all symbol tables in current symbol table. Will be useful for making sure that

mlir/lib/Catalyst/Transforms/catalyst_to_llvm.cpp

@@ -335,7 +335,8 @@ struct CustomCallOpPattern : public OpConversionPattern<CustomCallOp> {
         rewriter.setInsertionPointToStart(mod.getBody());
 
         LLVM::LLVMFuncOp customCallFnOp =
-            mlir::LLVM::lookupOrCreateFn(mod, op.getCallTargetName(), {/*args=*/ptr, /*rets=*/ptr},
+            mlir::LLVM::lookupOrCreateFn(rewriter, mod, op.getCallTargetName(),
+                                         {/*args=*/ptr, /*rets=*/ptr},
                                          /*ret_type=*/voidType)
                 .value();
         customCallFnOp.setPrivate();
@@ -467,7 +468,7 @@ struct DefineCallbackOpPattern : public OpConversionPattern<CallbackOp> {
         ModuleOp mod = op->getParentOfType<ModuleOp>();
         auto typeConverter = getTypeConverter();
         LLVM::LLVMFuncOp customCallFnOp =
-            mlir::LLVM::lookupOrCreateFn(mod, "__catalyst_inactive_callback",
+            mlir::LLVM::lookupOrCreateFn(rewriter, mod, "__catalyst_inactive_callback",
                                          {/*args=*/i64, i64, i64},
                                          /*ret_type=*/voidType, isVarArg)
                 .value();

mlir/lib/Gradient/Transforms/BufferizableOpInterfaceImpl.cpp

@@ -473,9 +473,9 @@ struct ForwardOpInterface
             // away.
             BaseMemRefType resultType = options.unknownTypeConverterFn(
                 returnVal, *options.defaultMemorySpaceFn(tensorType), options);
-            Value toMemrefOp =
-                rewriter.create<bufferization::ToMemrefOp>(loc, resultType, returnVal);
-            returnValues.push_back(toMemrefOp);
+            Value toBufferOp =
+                rewriter.create<bufferization::ToBufferOp>(loc, resultType, returnVal);
+            returnValues.push_back(toBufferOp);
         }
 
         // 3. Rewrite the terminator.
@@ -579,9 +579,9 @@ struct ReverseOpInterface
             // away.
             BaseMemRefType resultType = options.unknownTypeConverterFn(
                 returnVal, *options.defaultMemorySpaceFn(tensorType), options);
-            Value toMemrefOp =
-                rewriter.create<bufferization::ToMemrefOp>(loc, resultType, returnVal);
-            returnValues.push_back(toMemrefOp);
+            Value toBufferOp =
+                rewriter.create<bufferization::ToBufferOp>(loc, resultType, returnVal);
+            returnValues.push_back(toBufferOp);
         }
 
         // 3. Rewrite the terminator.

mlir/lib/Gradient/Transforms/GradMethods/FiniteDifference.cpp

@@ -163,10 +163,10 @@ void FiniteDiffLowering::computeFiniteDiff(PatternRewriter &rewriter, Location l
                     auto tensorTy = diffArg.getType();
                     auto memrefTy = bufferization::getMemRefTypeWithStaticIdentityLayout(
                         cast<TensorType>(tensorTy));
-                    auto toMemrefOp =
-                        rewriter.create<bufferization::ToMemrefOp>(loc, memrefTy, diffArg);
+                    auto toBufferOp =
+                        rewriter.create<bufferization::ToBufferOp>(loc, memrefTy, diffArg);
 
-                    auto cloneOp = rewriter.create<bufferization::CloneOp>(loc, toMemrefOp);
+                    auto cloneOp = rewriter.create<bufferization::CloneOp>(loc, toBufferOp);
 
                     auto toTensorOp =
                         rewriter.create<bufferization::ToTensorOp>(loc, cloneOp, true);

mlir/lib/Gradient/Transforms/GradMethods/HybridGradient.cpp

@@ -86,9 +86,9 @@ void initializeCotangents(TypeRange primalResultTypes, unsigned activeResult, Va
                             : activeResultType);
 
     Value zero = builder.create<arith::ConstantFloatOp>(
-        loc, APFloat(elementType.getFloatSemantics(), 0), elementType);
-    Value one = builder.create<arith::ConstantFloatOp>(
-        loc, APFloat(elementType.getFloatSemantics(), 1), elementType);
+        loc, elementType, APFloat(elementType.getFloatSemantics(), 0));
+    Value one = builder.create<arith::ConstantFloatOp>(loc, elementType,
+                                                       APFloat(elementType.getFloatSemantics(), 1));
 
     Value zeroTensor;
     if (auto activeResultTensor = dyn_cast<RankedTensorType>(activeResultType)) {
@@ -397,7 +397,7 @@ static func::FuncOp genFullGradFunction(PatternRewriter &rewriter, Location loc,
                 }
                 else {
                     jacobians.push_back(rewriter.create<arith::ConstantFloatOp>(
-                        loc, APFloat(0.0), cast<FloatType>(jacobianType)));
+                        loc, cast<FloatType>(jacobianType), APFloat(0.0)));
                 }
             }
 

mlir/lib/Gradient/Transforms/GradMethods/PS_FunctionShifting.cpp

@@ -35,7 +35,7 @@ static Value genSelectiveShift(PatternRewriter &rewriter, Location loc, Value pa
     }
 
     // Make sure all active iteration variables match the selectors.
-    Value shiftCondition = rewriter.create<arith::ConstantIntOp>(loc, true, 1);
+    Value shiftCondition = rewriter.create<arith::ConstantIntOp>(loc, 1, true);
     for (auto &[iteration, selector] : selectors) {
         Value iterationMatch =
             rewriter.create<arith::CmpIOp>(loc, arith::CmpIPredicate::eq, iteration, selector);

mlir/lib/Gradient/Utils/EinsumLinalgGeneric.cpp

@@ -44,7 +44,7 @@ Value buildTensorLinalgGeneric(OpBuilder &builder, Location loc, ValueRange oper
     // Initialize the result tensor
     FloatType elementType = cast<FloatType>(resultType.getElementType());
     Value zero = builder.create<arith::ConstantFloatOp>(
-        loc, APFloat::getZero(elementType.getFloatSemantics()), elementType);
+        loc, elementType, APFloat::getZero(elementType.getFloatSemantics()));
     Value result =
         builder.create<tensor::EmptyOp>(loc, resultType.getShape(), resultType.getElementType());
     result = builder.create<linalg::FillOp>(loc, zero, result).getResult(0);