[mlir][math] Added math::IPowI conversion to calls of outlined implementations.

[vzakhari]

Summary

Power functions are implemented as linkonce_odr scalar functions
for integer types used by IPowI operations met in a module.
Vector form of IPowI is linearized into a sequence of calls
of the scalar functions.

[vzakhari]

rebase

[vzakhari]

rebase

Please review.

[Mogball]

mlir/include/mlir/Conversion/Passes.td

491

Please change this back to a generic pass.

mlir/lib/Conversion/MathToLLVM/MathToLLVM.cpp

284

Lowering this to a function call is a little unusual. This lowering makes more sense to be a separate pass, because MathToLLVM is meant for trivial mostly one-to-one conversions

[vzakhari]

mlir/lib/Conversion/MathToLLVM/MathToLLVM.cpp

284

Okay, this makes sense! I will create a pass like MathToOutlinedImpl - please suggest if you can think of a better name.

[Mogball]

Is it possible to implement the function in arith or other math operations before lowing to LLVM? Probably MathExpandToFuncs

[vzakhari]

In D129810#3716668, @Mogball wrote:

Is it possible to implement the function in arith or other math operations before lowing to LLVM? Probably MathExpandToFuncs

It should be possible. Let me try it.

[Mogball]

mlir/include/mlir/Conversion/Passes.td

518

mlir/lib/Conversion/MathToFuncs/MathToFuncs.cpp

62–63 ↗

(On Diff #452842)

The type should only be omitted if it's explicit on the right hand side on an assignment due to a cast, or if it's "too long" (e.g. vector<int32_t>::iterator)

65–69 ↗

(On Diff #452842)

Can you add a failure reason with rewriter.notifyMatchFailure? It can notoriously difficult to debug pattern matching without those messages.

70 ↗

(On Diff #452842)

Spell out the auto.

71 ↗

(On Diff #452842)

Should this be unsigned?

78 ↗

(On Diff #452842)

Please don't use auto for a loop index.

89 ↗

(On Diff #452842)

129 ↗

(On Diff #452842)

Please spell out all the autos as appropriate.

139 ↗

(On Diff #452842)

Would generating this function be made any easier by using scf instead of cf?

327–329 ↗

(On Diff #452842)

Since this is a partial dialect conversion, can you not just add math::IPowI as an illegal op?

334–338 ↗

(On Diff #452842)

Nit: typically this comes before the pass declaration/definition

[vzakhari]

mlir/lib/Conversion/MathToFuncs/MathToFuncs.cpp

62–63 ↗

(On Diff #452842)

I will fix auto declarations. I will keep auto for results of rewriter.create<T> - it looks like it is a common practice to write it with auto.

65–69 ↗

(On Diff #452842)

Sure! Thanks for the suggestion!

71 ↗

(On Diff #452842)

int64_t should be correct, since ShapedType::getNumElements is defined as returning int64_t in IR/BuiltinAttributes.h.

139 ↗

(On Diff #452842)

It seems to me unstructured control flow fits better for the code with early returns from the function.

327–329 ↗

(On Diff #452842)

Will do.

[vzakhari]

Friendly ping. Please review.

[Mogball]

The high level idea makes sense to me, but I think the pass should be structured as:

1. Collect all element types for which functions need to be instantiated and instantiate those functions
2. Run the vector to scalar conversions and scalar to function call rewrites

mlir/include/mlir/Conversion/MathToFuncs/MathToFuncs.h

12 ↗

(On Diff #453059)

You can remove this include

23 ↗

(On Diff #453059)

These functions normally don't take a PatternBenefit.

26 ↗

(On Diff #453059)

These functions normally return just a Pass

mlir/include/mlir/Conversion/Passes.td

519

Why is this type of linkage needed? It's unfortunate that this pass depends on the LLVM dialect just for this.

mlir/lib/Conversion/MathToFuncs/MathToFuncs.cpp

124 ↗

(On Diff #453059)

It's generally not valid for patterns to access and modify parent operations, especially since these "patterns" are exposed publicly. The generation of these software implementations should not be done inside patterns. Patterns should be local rewrites of operations.

[vzakhari]

In D129810#3736207, @Mogball wrote:

The high level idea makes sense to me, but I think the pass should be structured as:

1. Collect all element types for which functions need to be instantiated and instantiate those functions
2. Run the vector to scalar conversions and scalar to function call rewrites

Can you please explain the benefit of such a split? There are 4 existing conversion passes that access their getNearestSymbolTable() "on the fly" (ComplexToLibm, MathToLibm, MemRefToSPIRV and SCFToOpenMP), and I do not really want to invent the wheel here :)

Thank you for the review! I will upload updated files shortly.

mlir/include/mlir/Conversion/MathToFuncs/MathToFuncs.h

23 ↗

(On Diff #453059)

There are some (e.g. ComplexToLLVM, MathToLibm), but it is currently not needed so I will remove it. It may be used in future in case there is target/project specific handling for such operations, e.g. in some cases there is target/project specific conversion for some flavors of the operation that is more preferable than MathToFuncs conversion - as I understand, in this case the patterns may be selected based on their benefit.

26 ↗

(On Diff #453059)

I see that many-many passes that are defined as ModuleOp passes in mlir/lib/Conversion/Passes.td (i.e. they are derived from Pass<"...", "ModuleOp">) all return std::unique_ptr<OperationPass<ModuleOp>> in the CPP files in mlir/lib/Conversion/*/*.cpp. I am not comfortable with stepping away from the common pattern. I guess it should be written this way to make it clear that the pass is not a generic pass but rather a specific operation pass.

mlir/include/mlir/Conversion/Passes.td

519

In FuncToLLVM conversion all func.func operations have external linkage by default. We cannot use external linkage for the generated functions, because there may be multiple definitions in different translation modules and the linking will fail. So we have to specify either internal or linkonce_odr linkage - the latter is better, because it allows the linker to keep only one copy of the generated function across multiple modules being linked.

I do not know of any other way to control linkage in MLIR.

mlir/lib/Conversion/MathToFuncs/MathToFuncs.cpp

124 ↗

(On Diff #453059)

I understand the concern. I followed the same approach that MathToLibm and ComplexToLibm use.

I guess I can add a comment in MathToFuncs.h to warn about valid usage of populateMathToFuncsConversionPatterns - does it make sense?

[vzakhari]

Addressed review remarks.

[Mogball]

The benefit is that the patterns won't 1. Keep looking up functions in the symbol table, which is painfully slow and 2. Won't violate the API contract for patterns.

mlir/include/mlir/Conversion/MathToFuncs/MathToFuncs.h

23 ↗

(On Diff #453059)

In that case, they wouldn't use these patterns or this pass. The validity of composing patterns is inconsistent.

26 ↗

(On Diff #453059)

It is inconsistent throughout the MLIR codebase, but please return a Pass. There is no benefit to returning OperationPass<ModuleOp> because the pass manager API only accepts the former anyways.

mlir/include/mlir/Conversion/Passes.td

519

Adding linkage to FuncDialect appears to be a TODO. It's fine for now then.

mlir/lib/Conversion/MathToFuncs/MathToFuncs.cpp

124 ↗

(On Diff #453059)

No. Those other patterns are also invalid. Patterns should not be modifying parent operations. It's something that "just happens to work" because no one has needed to compose these patterns sets in a parallelized pass (which would result in race conditions). This is especially true in conversion patterns, because there is extra bookkeeping in the dialect conversion pass that is violated if this happens.

Please don't propagate what has been done in the older passes and separate these.

[vzakhari]

mlir/include/mlir/Conversion/MathToFuncs/MathToFuncs.h

26 ↗

(On Diff #453059)

Will do.

mlir/lib/Conversion/MathToFuncs/MathToFuncs.cpp

124 ↗

(On Diff #453059)

Thank you for the explanation!

Then it looks like exposing the patterns is unsafe, in general, and I should rewrite the pass as you suggested without externalizing the match patterns (populateMathToFuncsConversionPatterns). The module pass will first visit all IPowI operations for collecting information about the kinds of implementation functions that need to be created in the module, then it will create the new functions, and then it will apply populateMathToFuncsConversionPatterns patterns to rewrite the operations into the calls.

[vzakhari]

Addressed review comments.

[Mogball]

Good evolution! The direction of the patch LGTM. I just have some minor complaints about the implementation details.

mlir/include/mlir/Conversion/MathToFuncs/MathToFuncs.h

14–16 ↗

(On Diff #455409)

mlir/include/mlir/Conversion/Passes.td

515

518–519

mlir/lib/Conversion/MathToFuncs/MathToFuncs.cpp

9–25 ↗

(On Diff #455409)

Can you trim these includes? I don't think all of these are needed

30–37 ↗

(On Diff #455409)

This isn't necessary. FunctionType can be hashed directly in a DenseMap.

153 ↗

(On Diff #455409)

I would prefer this to be a standalone function, not a static function on the pattern.

340–343 ↗

(On Diff #455409)

These two checks aren't necessary since they are invariants enforced by the verifier. You just need to check that this is a scalar integer op (done by the first condition).

376 ↗

(On Diff #455409)

383–384 ↗

(On Diff #455409)

385–387 ↗

(On Diff #455409)

If all the types are the same, then you only need to hash based on the element type.

[Mogball]

Do you also mind marking resolved comments as "done"?

[vzakhari]

Thank you for the prompt review!

mlir/lib/Conversion/MathToFuncs/MathToFuncs.cpp

383–384 ↗

(On Diff #455409)

Since I am going to add FPowI support later, does it make sense to keep the switch now?

385–387 ↗

(On Diff #455409)

This is true for IPowI but not for FPowI. I prefer to keep it as a function type so that the keys are consistent in the map, otherwise, for IPowI we will have IntegerType keys and for FPowI we will have FunctionType keys.

[vzakhari]

In D129810#3747847, @Mogball wrote:

Do you also mind marking resolved comments as "done"?

Done :)

[Mogball]

mlir/lib/Conversion/MathToFuncs/MathToFuncs.cpp

383–384 ↗

(On Diff #455409)

Yes it does. Thanks.

385–387 ↗

(On Diff #455409)

Then you can just use Type as the key.

385–387 ↗

(On Diff #455409)

In any case, you don't need std::map and a custom comparator. DenseMap<Type, T> works just fine.

[vzakhari]

mlir/lib/Conversion/MathToFuncs/MathToFuncs.cpp

385–387 ↗

(On Diff #455409)

Should be done now. Thanks!

[Mogball]

LGTM. Just one last complaint about the stringify/hashing

mlir/lib/Conversion/MathToFuncs/MathToFuncs.cpp

39 ↗

(On Diff #455726)

We generally don't use std::function

61 ↗

(On Diff #455726)

65 ↗

(On Diff #455726)

I think the "function type stringify" is too generic. For FPowI, just the floating point and integer type will suffice. This doesn't need to be done generally. I think you can just remove this function.

151–152 ↗

(On Diff #455726)

361–375 ↗

(On Diff #455726)

Can you remove the extra logic for now? I know you want to add support for other ops, but I think it'd be less automagical to just add another Case for FPowI

[vzakhari]

mlir/lib/Conversion/MathToFuncs/MathToFuncs.cpp

65 ↗

(On Diff #455726)

Okay, I will remove it.

151–152 ↗

(On Diff #455726)

Will do. flush should not be necessary according to this: https://llvm.org/doxygen/classllvm_1_1raw__string__ostream.html#details

[vzakhari]

Please let me know if everything looks good now. Thank you for all the feedback!

[Mogball]

LGTM.

mlir/include/mlir/Conversion/MathToLLVM/MathToLLVM.h

 //===- MathToLLVM.h - Math to LLVM dialect conversion -----------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef MLIR_CONVERSION_MATHTOLLVM_MATHTOLLVM_H
 #define MLIR_CONVERSION_MATHTOLLVM_MATHTOLLVM_H
 
 #include <memory>
 
 namespace mlir {
 
 class LLVMTypeConverter;
-class RewritePatternSet;
+class ModuleOp;
+template <typename T>
+class OperationPass;
 class Pass;
+class RewritePatternSet;
 
 void populateMathToLLVMConversionPatterns(LLVMTypeConverter &converter,
                                           RewritePatternSet &patterns);
 
-std::unique_ptr<Pass> createConvertMathToLLVMPass();
+std::unique_ptr<OperationPass<ModuleOp>> createConvertMathToLLVMPass();
 } // namespace mlir
 
 #endif // MLIR_CONVERSION_MATHTOLLVM_MATHTOLLVM_H

mlir/include/mlir/Conversion/Passes.td

let dependentDialects = [
     "vector::VectorDialect",
   ];
 }
 
 //===----------------------------------------------------------------------===//
 // MathToLLVM
 //===----------------------------------------------------------------------===//
 
-def ConvertMathToLLVM : Pass<"convert-math-to-llvm"> {
+def ConvertMathToLLVM : Pass<"convert-math-to-llvm", "ModuleOp"> {
   let summary = "Convert Math dialect to LLVM dialect";
   let description = [{
     This pass converts supported Math ops to LLVM dialect intrinsics.
   }];
   let constructor = "mlir::createConvertMathToLLVMPass()";
   let dependentDialects = ["LLVM::LLVMDialect"];
 }
 
 //===----------------------------------------------------------------------===//
 // MathToSPIRV
 //===----------------------------------------------------------------------===//
 
 def ConvertMathToSPIRV : Pass<"convert-math-to-spirv", "ModuleOp"> {
   let summary = "Convert Math dialect to SPIR-V dialect";
   let constructor = "mlir::createConvertMathToSPIRVPass()";
   let dependentDialects = ["spirv::SPIRVDialect"];
 }
 
 //===----------------------------------------------------------------------===//
 // MemRefToLLVM
 //===----------------------------------------------------------------------===//
 
 def ConvertMemRefToLLVM : Pass<"convert-memref-to-llvm", "ModuleOp"> {
   let summary = "Convert operations from the MemRef dialect to the LLVM "
                 "dialect";
   let constructor = "mlir::createMemRefToLLVMPass()";
   let dependentDialects = ["LLVM::LLVMDialect"];
   let options = [
     Option<"useAlignedAlloc", "use-aligned-alloc", "bool", /*default=*/"false",
            "Use aligned_alloc in place of malloc for heap allocations">,
     Option<"indexBitwidth", "index-bitwidth", "unsigned",
            /*default=kDeriveIndexBitwidthFromDataLayout*/"0",
            "Bitwidth of the index type, 0 to use size of machine word">,
   ];
 }
 

mlir/lib/Conversion/MathToLLVM/MathToLLVM.cpp

return LLVM::detail::handleMultidimensionalVectors(
           auto sqrt =
               rewriter.create<LLVM::SqrtOp>(loc, llvm1DVectorTy, operands[0]);
           return rewriter.create<LLVM::FDivOp>(loc, llvm1DVectorTy, one, sqrt);
         },
         rewriter);
   }
 };
 
+struct IPowIOpLowering : public ConvertOpToLLVMPattern<math::IPowIOp> {
+private:
+  /// Create linkonce_odr function to implement the power function with
+  /// the given \p elementType scalar type.
+  ///
+  /// template <typename T>
+  /// T __mlir_math_ipowi_*(T b, T p) {
+  ///   if (p == T(0))
+  ///     return T(1);
+  ///   if (p < T(0)) {
+  ///     if (b == T(0))
+  ///       return T(1) / T(0); // trigger div-by-zero
+  ///     if (b == T(1))
+  ///       return T(1);
+  ///     if (b == T(-1)) {
+  ///       if (p & T(1))
+  ///         return T(-1);
+  ///       return T(1);
+  ///     }
+  ///     return T(0);
+  ///   }
+  ///   T result = T(1);
+  ///   while (true) {
+  ///     if (p & T(1))
+  ///       result *= b;
+  ///     p >>= T(1);
+  ///     if (p == T(0))
+  ///       return result;
+  ///     b *= b;
+  ///   }
+  /// }
+  LLVM::LLVMFuncOp getElementFunc(math::IPowIOp op, IntegerType elementType,
+                                  PatternRewriter &rewriter) const {
+    std::string funcName("__mlir_math_ipowi_");
+    llvm::raw_string_ostream nameOS(funcName);
+    elementType.print(nameOS);
+
+    auto module = SymbolTable::getNearestSymbolTable(op);
+    auto funcType =
+        LLVM::LLVMFunctionType::get(elementType, {elementType, elementType});
+    if (auto funcOp = dyn_cast_or_null<LLVM::LLVMFuncOp>(
+            SymbolTable::lookupSymbolIn(module, funcName))) {
+      assert(funcOp.getFunctionTypeAttr().getValue() == funcType &&
+             "ipowi function type mismatch");
+      return funcOp;
+    }
+
+    OpBuilder::InsertionGuard guard(rewriter);
+    auto loc = rewriter.getUnknownLoc();
+    rewriter.setInsertionPointToEnd(&module->getRegion(0).front());
+    auto funcOp = rewriter.create<LLVM::LLVMFuncOp>(loc, funcName, funcType,
+                                                    LLVM::Linkage::LinkonceODR);
+    funcOp.setPrivate();
+
+    auto *entryBlock = funcOp.addEntryBlock();
+    auto *funcBody = entryBlock->getParent();
+
+    auto bArg = funcOp.getArgument(0);
+    auto pArg = funcOp.getArgument(1);
+    rewriter.setInsertionPointToEnd(entryBlock);
+    Value zeroValue = rewriter.create<LLVM::ConstantOp>(
+        loc, elementType, rewriter.getIntegerAttr(elementType, 0));
+    Value oneValue = rewriter.create<LLVM::ConstantOp>(
+        loc, elementType, rewriter.getIntegerAttr(elementType, 1));
+    Value minusOneValue = rewriter.create<LLVM::ConstantOp>(
+        loc, elementType,
+        rewriter.getIntegerAttr(elementType,
+                                APInt(elementType.getIntOrFloatBitWidth(),
+                                      -1ULL, /*isSigned=*/true)));
+
+    // if (p == T(0))
+    //   return T(1);
+    auto pIsZero = rewriter.create<LLVM::ICmpOp>(loc, LLVM::ICmpPredicate::eq,
+                                                 pArg, zeroValue);
+    auto *thenBlock = rewriter.createBlock(funcBody);
+    rewriter.create<LLVM::ReturnOp>(loc, oneValue);
+    auto *fallthroughBlock = rewriter.createBlock(funcBody);
+    // Set up conditional branch for (p == T(0)).
+    rewriter.setInsertionPointToEnd(pIsZero->getBlock());
+    rewriter.create<LLVM::CondBrOp>(loc, pIsZero, thenBlock, fallthroughBlock);
+
+    // if (p < T(0)) {
+    rewriter.setInsertionPointToEnd(fallthroughBlock);
+    auto pIsNeg = rewriter.create<LLVM::ICmpOp>(loc, LLVM::ICmpPredicate::sle,
+                                                pArg, zeroValue);
+    //   if (b == T(0))
+    rewriter.createBlock(funcBody);
+    auto bIsZero = rewriter.create<LLVM::ICmpOp>(loc, LLVM::ICmpPredicate::eq,
+                                                 bArg, zeroValue);
+    //     return T(1) / T(0);
+    thenBlock = rewriter.createBlock(funcBody);
+    rewriter.create<LLVM::ReturnOp>(
+        loc,
+        rewriter.create<LLVM::SDivOp>(loc, oneValue, zeroValue).getResult());
+    fallthroughBlock = rewriter.createBlock(funcBody);
+    // Set up conditional branch for (b == T(0)).
+    rewriter.setInsertionPointToEnd(bIsZero->getBlock());
+    rewriter.create<LLVM::CondBrOp>(loc, bIsZero, thenBlock, fallthroughBlock);
+
+    //   if (b == T(1))
+    rewriter.setInsertionPointToEnd(fallthroughBlock);
+    auto bIsOne = rewriter.create<LLVM::ICmpOp>(loc, LLVM::ICmpPredicate::eq,
+                                                bArg, oneValue);
+    //    return T(1);
+    thenBlock = rewriter.createBlock(funcBody);
+    rewriter.create<LLVM::ReturnOp>(loc, oneValue);
+    fallthroughBlock = rewriter.createBlock(funcBody);
+    // Set up conditional branch for (b == T(1)).
+    rewriter.setInsertionPointToEnd(bIsOne->getBlock());
+    rewriter.create<LLVM::CondBrOp>(loc, bIsOne, thenBlock, fallthroughBlock);
+
+    //   if (b == T(-1)) {
+    rewriter.setInsertionPointToEnd(fallthroughBlock);
+    auto bIsMinusOne = rewriter.create<LLVM::ICmpOp>(
+        loc, LLVM::ICmpPredicate::eq, bArg, minusOneValue);
+    //     if (p & T(1))
+    rewriter.createBlock(funcBody);
+    auto pIsOdd = rewriter.create<LLVM::ICmpOp>(
+        loc, LLVM::ICmpPredicate::ne,
+        rewriter.create<LLVM::AndOp>(loc, pArg, oneValue), zeroValue);
+    //       return T(-1);
+    thenBlock = rewriter.createBlock(funcBody);
+    rewriter.create<LLVM::ReturnOp>(loc, minusOneValue);
+    fallthroughBlock = rewriter.createBlock(funcBody);
+    // Set up conditional branch for (p & T(1)).
+    rewriter.setInsertionPointToEnd(pIsOdd->getBlock());
+    rewriter.create<LLVM::CondBrOp>(loc, pIsOdd, thenBlock, fallthroughBlock);
+
+    //     return T(1);
+    //   } // b == T(-1)
+    rewriter.setInsertionPointToEnd(fallthroughBlock);
+    rewriter.create<LLVM::ReturnOp>(loc, oneValue);
+    fallthroughBlock = rewriter.createBlock(funcBody);
+    // Set up conditional branch for (b == T(-1)).
+    rewriter.setInsertionPointToEnd(bIsMinusOne->getBlock());
+    rewriter.create<LLVM::CondBrOp>(loc, bIsMinusOne, pIsOdd->getBlock(),
+                                    fallthroughBlock);
+
+    //   return T(0);
+    // } // (p < T(0))
+    rewriter.setInsertionPointToEnd(fallthroughBlock);
+    rewriter.create<LLVM::ReturnOp>(loc, zeroValue);
+    auto *loopHeader = rewriter.createBlock(
+        funcBody, funcBody->end(), {elementType, elementType, elementType},
+        {loc, loc, loc});
+    // Set up conditional branch for (p < T(0)).
+    rewriter.setInsertionPointToEnd(pIsNeg->getBlock());
+    // Set initial values of 'result', 'b' and 'p' for the loop.
+    rewriter.create<LLVM::CondBrOp>(loc, pIsNeg, bIsZero->getBlock(),
+                                    loopHeader,
+                                    ValueRange{oneValue, bArg, pArg});
+
+    // T result = T(1);
+    // while (true) {
+    //   if (p & T(1))
+    //     result *= b;
+    //   p >>= T(1);
+    //   if (p == T(0))
+    //     return result;
+    //   b *= b;
+    // }
+    Value resultTmp = loopHeader->getArgument(0);
+    Value baseTmp = loopHeader->getArgument(1);
+    Value powerTmp = loopHeader->getArgument(2);
+    rewriter.setInsertionPointToEnd(loopHeader);
+
+    //   if (p & T(1))
+    auto powerTmpIsOdd = rewriter.create<LLVM::ICmpOp>(
+        loc, LLVM::ICmpPredicate::ne,
+        rewriter.create<LLVM::AndOp>(loc, powerTmp, oneValue), zeroValue);
+    thenBlock = rewriter.createBlock(funcBody);
+    //     result *= b;
+    Value newResultTmp = rewriter.create<LLVM::MulOp>(loc, resultTmp, baseTmp);
+    fallthroughBlock =
+        rewriter.createBlock(funcBody, funcBody->end(), elementType, loc);
+    rewriter.setInsertionPointToEnd(thenBlock);
+    rewriter.create<LLVM::BrOp>(loc, newResultTmp, fallthroughBlock);
+    // Set up conditional branch for (p & T(1)).
+    rewriter.setInsertionPointToEnd(powerTmpIsOdd->getBlock());
+    rewriter.create<LLVM::CondBrOp>(loc, powerTmpIsOdd, thenBlock,
+                                    fallthroughBlock, resultTmp);
+    // Merged 'result'.
+    newResultTmp = fallthroughBlock->getArgument(0);
+
+    //   p >>= T(1);
+    rewriter.setInsertionPointToEnd(fallthroughBlock);
+    Value newPowerTmp = rewriter.create<LLVM::AShrOp>(loc, powerTmp, oneValue);
+
+    //   if (p == T(0))
+    auto newPowerIsZero = rewriter.create<LLVM::ICmpOp>(
+        loc, LLVM::ICmpPredicate::eq, newPowerTmp, zeroValue);
+    //     return result;
+    thenBlock = rewriter.createBlock(funcBody);
+    rewriter.create<LLVM::ReturnOp>(loc, newResultTmp);
+    fallthroughBlock = rewriter.createBlock(funcBody);
+    // Set up conditional branch for (p == T(0)).
+    rewriter.setInsertionPointToEnd(newPowerIsZero->getBlock());
+    rewriter.create<LLVM::CondBrOp>(loc, newPowerIsZero, thenBlock,
+                                    fallthroughBlock);
+
+    //   b *= b;
+    // }
+    rewriter.setInsertionPointToEnd(fallthroughBlock);
+    Value newBaseTmp = rewriter.create<LLVM::MulOp>(loc, baseTmp, baseTmp);
+    // Pass new values for 'result', 'b' and 'p' to the loop header.
+    rewriter.create<LLVM::BrOp>(
+        loc, ValueRange{newResultTmp, newBaseTmp, newPowerTmp}, loopHeader);
+    return funcOp;
+  }
+
+public:
+  using ConvertOpToLLVMPattern<math::IPowIOp>::ConvertOpToLLVMPattern;
+
+  /// Convert IPowI into a call to a local function implementing
+  /// the power operation. The local function computes a scalar result,
+  /// so vector forms of IPowI are linearized.
+  LogicalResult
+  matchAndRewrite(math::IPowIOp op, OpAdaptor adaptor,
+                  ConversionPatternRewriter &rewriter) const override {
+    auto operandType = adaptor.getOperands()[0].getType();
+
+    if (!operandType || !LLVM::isCompatibleType(operandType))
+      return failure();
+
+    auto loc = op.getLoc();
+    if (auto elementType = operandType.dyn_cast<IntegerType>()) {
+      auto elementFunc = getElementFunc(op, elementType, rewriter);
+      rewriter.replaceOpWithNewOp<LLVM::CallOp>(op, elementFunc,
+                                                adaptor.getOperands());
+      return success();
+    }
+
+    auto resultType = op.getResult().getType();
+    auto vectorType = resultType.dyn_cast<VectorType>();
+    if (!vectorType)
+      return failure();
+
+    auto elementType = vectorType.getElementType().dyn_cast<IntegerType>();
+    if (!elementType)
+      return failure();
+
+    auto elementFunc = getElementFunc(op, elementType, rewriter);
+    return LLVM::detail::handleMultidimensionalVectors(
+        op.getOperation(), adaptor.getOperands(), *getTypeConverter(),
+        [&](Type llvm1DVectorTy, ValueRange operands) {
+          Value result = rewriter.create<LLVM::UndefOp>(loc, llvm1DVectorTy);
+          auto vecType = llvm1DVectorTy.cast<VectorType>();
+          for (unsigned idx = 0, numElements = vecType.getNumElements();
+               idx < numElements; ++idx) {
+            Value pos = rewriter.create<LLVM::ConstantOp>(
+                loc, rewriter.getI64Type(), rewriter.getI64IntegerAttr(idx));
+            Value baseOp =
+                rewriter.create<LLVM::ExtractElementOp>(loc, operands[0], pos);
+            Value powerOp =
+                rewriter.create<LLVM::ExtractElementOp>(loc, operands[1], pos);
+            Value eltResult =
+                rewriter
+                    .create<LLVM::CallOp>(loc, elementFunc,
+                                          ValueRange{baseOp, powerOp})
+                    .getResult(0);
+            result = rewriter.create<LLVM::InsertElementOp>(
+                loc, llvm1DVectorTy, result, eltResult, pos);
+          }
+          return result;
+        },
+        rewriter);
+  }
+};
+
 struct ConvertMathToLLVMPass
     : public ConvertMathToLLVMBase<ConvertMathToLLVMPass> {
   ConvertMathToLLVMPass() = default;
 
   void runOnOperation() override {
     RewritePatternSet patterns(&getContext());
     LLVMTypeConverter converter(&getContext());
     populateMathToLLVMConversionPatterns(converter, patterns);
     LLVMConversionTarget target(getContext());
+    target.addIllegalDialect<math::MathDialect>();
     if (failed(applyPartialConversion(getOperation(), target,
                                       std::move(patterns))))
       signalPassFailure();
   }
 };
 } // namespace
 
 void mlir::populateMathToLLVMConversionPatterns(LLVMTypeConverter &converter,
patterns.add<
     ExpOpLowering,
     FloorOpLowering,
     FmaOpLowering,
     Log10OpLowering,
     Log1pOpLowering,
     Log2OpLowering,
     LogOpLowering,
     PowFOpLowering,
+    IPowIOpLowering,
     RoundOpLowering,
     RsqrtOpLowering,
     SinOpLowering,
     SqrtOpLowering
   >(converter);
   // clang-format on
 }
 
-std::unique_ptr<Pass> mlir::createConvertMathToLLVMPass() {
+std::unique_ptr<OperationPass<ModuleOp>> mlir::createConvertMathToLLVMPass() {
   return std::make_unique<ConvertMathToLLVMPass>();
 }

mlir/lib/Dialect/SparseTensor/Pipelines/SparseTensorPipelines.cpp

void mlir::sparse_tensor::buildSparseCompiler(
   // it to this pipeline.
   pm.addNestedPass<func::FuncOp>(createConvertLinalgToLoopsPass());
   pm.addNestedPass<func::FuncOp>(createConvertVectorToSCFPass());
   pm.addNestedPass<func::FuncOp>(createConvertSCFToCFPass());
   pm.addPass(createLowerAffinePass());
   pm.addPass(createConvertVectorToLLVMPass(options.lowerVectorToLLVMOptions()));
   pm.addPass(createMemRefToLLVMPass());
   pm.addNestedPass<func::FuncOp>(createConvertComplexToStandardPass());
-  pm.addNestedPass<func::FuncOp>(createConvertMathToLLVMPass());
+  pm.addPass(createConvertMathToLLVMPass());
   pm.addPass(createConvertMathToLibmPass());
   pm.addPass(createConvertComplexToLibmPass());
   pm.addPass(createConvertComplexToLLVMPass());
   pm.addPass(createConvertFuncToLLVMPass());
   pm.addPass(createReconcileUnrealizedCastsPass());
 }
 
 //===----------------------------------------------------------------------===//

mlir/test/Conversion/ComplexToStandard/full-conversion.mlir

-// RUN: mlir-opt %s -pass-pipeline="func.func(convert-complex-to-standard),convert-complex-to-llvm,func.func(convert-math-to-llvm,convert-arith-to-llvm),convert-func-to-llvm,reconcile-unrealized-casts" | FileCheck %s
+// RUN: mlir-opt %s -pass-pipeline="func.func(convert-complex-to-standard),convert-complex-to-llvm,convert-math-to-llvm,func.func(convert-arith-to-llvm),convert-func-to-llvm,reconcile-unrealized-casts" | FileCheck %s
 
 // CHECK-LABEL: llvm.func @complex_abs
 // CHECK-SAME: %[[ARG:.*]]: ![[C_TY:.*]])
 func.func @complex_abs(%arg: complex<f32>) -> f32 {
   %abs = complex.abs %arg: complex<f32>
   return %abs : f32
 }
 // CHECK: %[[REAL:.*]] = llvm.extractvalue %[[ARG]][0] : ![[C_TY]]

mlir/test/Conversion/FuncToLLVM/func-to-llvm.mlir

-// RUN: mlir-opt -pass-pipeline="func.func(convert-math-to-llvm,convert-arith-to-llvm),convert-func-to-llvm,reconcile-unrealized-casts" %s -split-input-file | FileCheck %s
-// RUN: mlir-opt -pass-pipeline="func.func(convert-math-to-llvm,convert-arith-to-llvm{index-bitwidth=32}),convert-func-to-llvm{index-bitwidth=32},reconcile-unrealized-casts" %s -split-input-file | FileCheck --check-prefix=CHECK32 %s
+// RUN: mlir-opt -pass-pipeline="convert-math-to-llvm,func.func(convert-arith-to-llvm),convert-func-to-llvm,reconcile-unrealized-casts" %s -split-input-file | FileCheck %s
+// RUN: mlir-opt -pass-pipeline="convert-math-to-llvm,func.func(convert-arith-to-llvm{index-bitwidth=32}),convert-func-to-llvm{index-bitwidth=32},reconcile-unrealized-casts" %s -split-input-file | FileCheck --check-prefix=CHECK32 %s
 
 // CHECK-LABEL: func @empty() {
 // CHECK-NEXT:  llvm.return
 // CHECK-NEXT: }
 func.func @empty() {
 ^bb0:
   return
 }

mlir/test/Conversion/MathToLLVM/math-to-llvm.mlir

-// RUN: mlir-opt %s -split-input-file -pass-pipeline="func.func(convert-math-to-llvm)" | FileCheck %s
+// RUN: mlir-opt %s -split-input-file -pass-pipeline="convert-math-to-llvm" | FileCheck %s
 
 // CHECK-LABEL: @ops
 func.func @ops(%arg0: f32, %arg1: f32, %arg2: i32, %arg3: i32, %arg4: f64) {
 // CHECK: = "llvm.intr.exp"(%{{.*}}) : (f32) -> f32
   %13 = math.exp %arg0 : f32
 // CHECK: = "llvm.intr.exp2"(%{{.*}}) : (f32) -> f32
   %14 = math.exp2 %arg0 : f32
 // CHECK: = "llvm.intr.sqrt"(%{{.*}}) : (f32) -> f32

 
 // CHECK-LABEL: func @round(
 // CHECK-SAME: f32
 func.func @round(%arg0 : f32) {
   // CHECK: "llvm.intr.round"(%arg0) : (f32) -> f32
   %0 = math.round %arg0 : f32
   func.return
 }
+
+// -----
+
+// CHECK-LABEL: func @ipowi(
+// CHECK-SAME: %[[ARG0:.+]]: i64,
+// CHECK-SAME: %[[ARG1:.+]]: i64)
+func.func @ipowi(%arg0: i64, %arg1: i64) {
+  // CHECK: llvm.call @__mlir_math_ipowi_i64(%[[ARG0]], %[[ARG1]]) : (i64, i64) -> i64
+  %0 = math.ipowi %arg0, %arg1 : i64
+  func.return
+}
+
+// CHECK-LABEL:   llvm.func linkonce_odr @__mlir_math_ipowi_i64(
+// CHECK-SAME:                                                   %[[VAL_0:.*]]: i64,
+// CHECK-SAME:                                                   %[[VAL_1:.*]]: i64) -> i64 attributes {sym_visibility = "private"} {
+// CHECK:           %[[VAL_2:.*]] = llvm.mlir.constant(0 : i64) : i64
+// CHECK:           %[[VAL_3:.*]] = llvm.mlir.constant(1 : i64) : i64
+// CHECK:           %[[VAL_4:.*]] = llvm.mlir.constant(-1 : i64) : i64
+// CHECK:           %[[VAL_5:.*]] = llvm.icmp "eq" %[[VAL_1]], %[[VAL_2]] : i64
+// CHECK:           llvm.cond_br %[[VAL_5]], ^bb1, ^bb2
+// CHECK:         ^bb1:
+// CHECK:           llvm.return %[[VAL_3]] : i64
+// CHECK:         ^bb2:
+// CHECK:           %[[VAL_6:.*]] = llvm.icmp "sle" %[[VAL_1]], %[[VAL_2]] : i64
+// CHECK:           llvm.cond_br %[[VAL_6]], ^bb3, ^bb12(%[[VAL_3]], %[[VAL_0]], %[[VAL_1]] : i64, i64, i64)
+// CHECK:         ^bb3:
+// CHECK:           %[[VAL_7:.*]] = llvm.icmp "eq" %[[VAL_0]], %[[VAL_2]] : i64
+// CHECK:           llvm.cond_br %[[VAL_7]], ^bb4, ^bb5
+// CHECK:         ^bb4:
+// CHECK:           %[[VAL_8:.*]] = llvm.sdiv %[[VAL_3]], %[[VAL_2]]  : i64
+// CHECK:           llvm.return %[[VAL_8]] : i64
+// CHECK:         ^bb5:
+// CHECK:           %[[VAL_9:.*]] = llvm.icmp "eq" %[[VAL_0]], %[[VAL_3]] : i64
+// CHECK:           llvm.cond_br %[[VAL_9]], ^bb6, ^bb7
+// CHECK:         ^bb6:
+// CHECK:           llvm.return %[[VAL_3]] : i64
+// CHECK:         ^bb7:
+// CHECK:           %[[VAL_10:.*]] = llvm.icmp "eq" %[[VAL_0]], %[[VAL_4]] : i64
+// CHECK:           llvm.cond_br %[[VAL_10]], ^bb8, ^bb11
+// CHECK:         ^bb8:
+// CHECK:           %[[VAL_11:.*]] = llvm.and %[[VAL_1]], %[[VAL_3]]  : i64
+// CHECK:           %[[VAL_12:.*]] = llvm.icmp "ne" %[[VAL_11]], %[[VAL_2]] : i64
+// CHECK:           llvm.cond_br %[[VAL_12]], ^bb9, ^bb10
+// CHECK:         ^bb9:
+// CHECK:           llvm.return %[[VAL_4]] : i64
+// CHECK:         ^bb10:
+// CHECK:           llvm.return %[[VAL_3]] : i64
+// CHECK:         ^bb11:
+// CHECK:           llvm.return %[[VAL_2]] : i64
+// CHECK:         ^bb12(%[[VAL_13:.*]]: i64, %[[VAL_14:.*]]: i64, %[[VAL_15:.*]]: i64):
+// CHECK:           %[[VAL_16:.*]] = llvm.and %[[VAL_15]], %[[VAL_3]]  : i64
+// CHECK:           %[[VAL_17:.*]] = llvm.icmp "ne" %[[VAL_16]], %[[VAL_2]] : i64
+// CHECK:           llvm.cond_br %[[VAL_17]], ^bb13, ^bb14(%[[VAL_13]] : i64)
+// CHECK:         ^bb13:
+// CHECK:           %[[VAL_18:.*]] = llvm.mul %[[VAL_13]], %[[VAL_14]]  : i64
+// CHECK:           llvm.br ^bb14(%[[VAL_18]] : i64)
+// CHECK:         ^bb14(%[[VAL_19:.*]]: i64):
+// CHECK:           %[[VAL_20:.*]] = llvm.ashr %[[VAL_15]], %[[VAL_3]]  : i64
+// CHECK:           %[[VAL_21:.*]] = llvm.icmp "eq" %[[VAL_20]], %[[VAL_2]] : i64
+// CHECK:           llvm.cond_br %[[VAL_21]], ^bb15, ^bb16
+// CHECK:         ^bb15:
+// CHECK:           llvm.return %[[VAL_19]] : i64
+// CHECK:         ^bb16:
+// CHECK:           %[[VAL_22:.*]] = llvm.mul %[[VAL_14]], %[[VAL_14]]  : i64
+// CHECK:           llvm.br ^bb12(%[[VAL_19]], %[[VAL_22]], %[[VAL_20]] : i64, i64, i64)
+// CHECK:         }
+
+// -----
+
+// CHECK-LABEL: func @ipowi(
+// CHECK-SAME: %[[ARG0:.+]]: i8,
+// CHECK-SAME: %[[ARG1:.+]]: i8)
+  // CHECK: llvm.call @__mlir_math_ipowi_i8(%[[ARG0]], %[[ARG1]]) : (i8, i8) -> i8
+func.func @ipowi(%arg0: i8, %arg1: i8) {
+  %0 = math.ipowi %arg0, %arg1 : i8
+  func.return
+}
+
+// CHECK-LABEL:   llvm.func linkonce_odr @__mlir_math_ipowi_i8(
+// CHECK-SAME:                                                  %[[VAL_0:.*]]: i8,
+// CHECK-SAME:                                                  %[[VAL_1:.*]]: i8) -> i8 attributes {sym_visibility = "private"} {
+// CHECK:           %[[VAL_2:.*]] = llvm.mlir.constant(0 : i8) : i8
+// CHECK:           %[[VAL_3:.*]] = llvm.mlir.constant(1 : i8) : i8
+// CHECK:           %[[VAL_4:.*]] = llvm.mlir.constant(-1 : i8) : i8
+// CHECK:           %[[VAL_5:.*]] = llvm.icmp "eq" %[[VAL_1]], %[[VAL_2]] : i8
+// CHECK:           llvm.cond_br %[[VAL_5]], ^bb1, ^bb2
+// CHECK:         ^bb1:
+// CHECK:           llvm.return %[[VAL_3]] : i8
+// CHECK:         ^bb2:
+// CHECK:           %[[VAL_6:.*]] = llvm.icmp "sle" %[[VAL_1]], %[[VAL_2]] : i8
+// CHECK:           llvm.cond_br %[[VAL_6]], ^bb3, ^bb12(%[[VAL_3]], %[[VAL_0]], %[[VAL_1]] : i8, i8, i8)
+// CHECK:         ^bb3:
+// CHECK:           %[[VAL_7:.*]] = llvm.icmp "eq" %[[VAL_0]], %[[VAL_2]] : i8
+// CHECK:           llvm.cond_br %[[VAL_7]], ^bb4, ^bb5
+// CHECK:         ^bb4:
+// CHECK:           %[[VAL_8:.*]] = llvm.sdiv %[[VAL_3]], %[[VAL_2]]  : i8
+// CHECK:           llvm.return %[[VAL_8]] : i8
+// CHECK:         ^bb5:
+// CHECK:           %[[VAL_9:.*]] = llvm.icmp "eq" %[[VAL_0]], %[[VAL_3]] : i8
+// CHECK:           llvm.cond_br %[[VAL_9]], ^bb6, ^bb7
+// CHECK:         ^bb6:
+// CHECK:           llvm.return %[[VAL_3]] : i8
+// CHECK:         ^bb7:
+// CHECK:           %[[VAL_10:.*]] = llvm.icmp "eq" %[[VAL_0]], %[[VAL_4]] : i8
+// CHECK:           llvm.cond_br %[[VAL_10]], ^bb8, ^bb11
+// CHECK:         ^bb8:
+// CHECK:           %[[VAL_11:.*]] = llvm.and %[[VAL_1]], %[[VAL_3]]  : i8
+// CHECK:           %[[VAL_12:.*]] = llvm.icmp "ne" %[[VAL_11]], %[[VAL_2]] : i8
+// CHECK:           llvm.cond_br %[[VAL_12]], ^bb9, ^bb10
+// CHECK:         ^bb9:
+// CHECK:           llvm.return %[[VAL_4]] : i8
+// CHECK:         ^bb10:
+// CHECK:           llvm.return %[[VAL_3]] : i8
+// CHECK:         ^bb11:
+// CHECK:           llvm.return %[[VAL_2]] : i8
+// CHECK:         ^bb12(%[[VAL_13:.*]]: i8, %[[VAL_14:.*]]: i8, %[[VAL_15:.*]]: i8):
+// CHECK:           %[[VAL_16:.*]] = llvm.and %[[VAL_15]], %[[VAL_3]]  : i8
+// CHECK:           %[[VAL_17:.*]] = llvm.icmp "ne" %[[VAL_16]], %[[VAL_2]] : i8
+// CHECK:           llvm.cond_br %[[VAL_17]], ^bb13, ^bb14(%[[VAL_13]] : i8)
+// CHECK:         ^bb13:
+// CHECK:           %[[VAL_18:.*]] = llvm.mul %[[VAL_13]], %[[VAL_14]]  : i8
+// CHECK:           llvm.br ^bb14(%[[VAL_18]] : i8)
+// CHECK:         ^bb14(%[[VAL_19:.*]]: i8):
+// CHECK:           %[[VAL_20:.*]] = llvm.ashr %[[VAL_15]], %[[VAL_3]]  : i8
+// CHECK:           %[[VAL_21:.*]] = llvm.icmp "eq" %[[VAL_20]], %[[VAL_2]] : i8
+// CHECK:           llvm.cond_br %[[VAL_21]], ^bb15, ^bb16
+// CHECK:         ^bb15:
+// CHECK:           llvm.return %[[VAL_19]] : i8
+// CHECK:         ^bb16:
+// CHECK:           %[[VAL_22:.*]] = llvm.mul %[[VAL_14]], %[[VAL_14]]  : i8
+// CHECK:           llvm.br ^bb12(%[[VAL_19]], %[[VAL_22]], %[[VAL_20]] : i8, i8, i8)
+// CHECK:         }
+
+// -----
+
+// CHECK-LABEL:   func.func @ipowi_vec(
+// CHECK-SAME:                          %[[VAL_0:.*]]: vector<2x3xi64>,
+// CHECK-SAME:                          %[[VAL_1:.*]]: vector<2x3xi64>) {
+func.func @ipowi_vec(%arg0: vector<2x3xi64>, %arg1: vector<2x3xi64>) {
+// CHECK:           %[[VAL_4:.*]] = llvm.mlir.undef : !llvm.array<2 x vector<3xi64>>
+// CHECK:           %[[VAL_5:.*]] = llvm.extractvalue %[[VAL_2:.*]][0] : !llvm.array<2 x vector<3xi64>>
+// CHECK:           %[[VAL_6:.*]] = llvm.extractvalue %[[VAL_3:.*]][0] : !llvm.array<2 x vector<3xi64>>
+// CHECK:           %[[VAL_7:.*]] = llvm.mlir.undef : vector<3xi64>
+// CHECK:           %[[VAL_8:.*]] = llvm.mlir.constant(0 : i64) : i64
+// CHECK:           %[[VAL_9:.*]] = llvm.extractelement %[[VAL_5]]{{\[}}%[[VAL_8]] : i64] : vector<3xi64>
+// CHECK:           %[[VAL_10:.*]] = llvm.extractelement %[[VAL_6]]{{\[}}%[[VAL_8]] : i64] : vector<3xi64>
+// CHECK:           %[[VAL_11:.*]] = llvm.call @__mlir_math_ipowi_i64(%[[VAL_9]], %[[VAL_10]]) : (i64, i64) -> i64
+// CHECK:           %[[VAL_12:.*]] = llvm.insertelement %[[VAL_11]], %[[VAL_7]]{{\[}}%[[VAL_8]] : i64] : vector<3xi64>
+// CHECK:           %[[VAL_13:.*]] = llvm.mlir.constant(1 : i64) : i64
+// CHECK:           %[[VAL_14:.*]] = llvm.extractelement %[[VAL_5]]{{\[}}%[[VAL_13]] : i64] : vector<3xi64>
+// CHECK:           %[[VAL_15:.*]] = llvm.extractelement %[[VAL_6]]{{\[}}%[[VAL_13]] : i64] : vector<3xi64>
+// CHECK:           %[[VAL_16:.*]] = llvm.call @__mlir_math_ipowi_i64(%[[VAL_14]], %[[VAL_15]]) : (i64, i64) -> i64
+// CHECK:           %[[VAL_17:.*]] = llvm.insertelement %[[VAL_16]], %[[VAL_12]]{{\[}}%[[VAL_13]] : i64] : vector<3xi64>
+// CHECK:           %[[VAL_18:.*]] = llvm.mlir.constant(2 : i64) : i64
+// CHECK:           %[[VAL_19:.*]] = llvm.extractelement %[[VAL_5]]{{\[}}%[[VAL_18]] : i64] : vector<3xi64>
+// CHECK:           %[[VAL_20:.*]] = llvm.extractelement %[[VAL_6]]{{\[}}%[[VAL_18]] : i64] : vector<3xi64>
+// CHECK:           %[[VAL_21:.*]] = llvm.call @__mlir_math_ipowi_i64(%[[VAL_19]], %[[VAL_20]]) : (i64, i64) -> i64
+// CHECK:           %[[VAL_22:.*]] = llvm.insertelement %[[VAL_21]], %[[VAL_17]]{{\[}}%[[VAL_18]] : i64] : vector<3xi64>
+// CHECK:           %[[VAL_23:.*]] = llvm.insertvalue %[[VAL_22]], %[[VAL_4]][0] : !llvm.array<2 x vector<3xi64>>
+
+// CHECK:           llvm.call @__mlir_math_ipowi_i64(%{{.*}}, %{{.*}}) : (i64, i64) -> i64
+// CHECK:           llvm.call @__mlir_math_ipowi_i64(%{{.*}}, %{{.*}}) : (i64, i64) -> i64
+// CHECK:           llvm.call @__mlir_math_ipowi_i64(%{{.*}}, %{{.*}}) : (i64, i64) -> i64
+  %0 = math.ipowi %arg0, %arg1 : vector<2x3xi64>
+  func.return
+}

mlir/test/mlir-cpu-runner/math-polynomial-approx.mlir

-// RUN:   mlir-opt %s -pass-pipeline="func.func(test-math-polynomial-approximation,convert-arith-to-llvm),convert-vector-to-llvm,func.func(convert-math-to-llvm),convert-func-to-llvm,reconcile-unrealized-casts" \
+// RUN:   mlir-opt %s -pass-pipeline="func.func(test-math-polynomial-approximation,convert-arith-to-llvm),convert-vector-to-llvm,convert-math-to-llvm,convert-func-to-llvm,reconcile-unrealized-casts" \
 // RUN: | mlir-cpu-runner                                                      \
 // RUN:     -e main -entry-point-result=void -O0                               \
 // RUN:     -shared-libs=%linalg_test_lib_dir/libmlir_c_runner_utils%shlibext  \
 // RUN:     -shared-libs=%linalg_test_lib_dir/libmlir_runner_utils%shlibext    \
 // RUN: | FileCheck %s
 
 // -------------------------------------------------------------------------- //
 // Tanh.