[mlir][math] Added arith::FastMathAttr support for math::FPowI.

[kiranchandramohan]

LGTM.

mlir/include/mlir/Dialect/Math/IR/MathOps.td

def Math_TruncOp : Math_FloatUnaryOp<"trunc"> {
   let hasFolder = 1;
 }
 
 //===----------------------------------------------------------------------===//
 // FPowIOp
 //===----------------------------------------------------------------------===//
 
 def Math_FPowIOp : Math_Op<"fpowi",
-    [SameOperandsAndResultShape, AllTypesMatch<["lhs", "result"]>]> {
+    [SameOperandsAndResultShape, AllTypesMatch<["lhs", "result"]>,
+     DeclareOpInterfaceMethods<ArithFastMathInterface>]> {
   let summary = "floating point raised to the signed integer power";
   let description = [{
     Syntax:
 
     ```
     operation ::= ssa-id `=` `math.fpowi` ssa-use `,` ssa-use `:` type
     ```
 
let description = [{
     Example:
 
     ```mlir
     // Scalar exponentiation.
     %a = math.fpowi %base, %power : f64, i32
     ```
   }];
 
-  let arguments = (ins FloatLike:$lhs, SignlessIntegerLike:$rhs);
+  let arguments = (ins FloatLike:$lhs, SignlessIntegerLike:$rhs,
+      DefaultValuedAttr<Arith_FastMathAttr,
+                        "::mlir::arith::FastMathFlags::none">:$fastmath);
   let results = (outs FloatLike:$result);
-  let assemblyFormat = "$lhs `,` $rhs attr-dict `:` type($lhs) `,` type($rhs)";
+  let assemblyFormat = [{ $lhs `,` $rhs (`fastmath` `` $fastmath^)?
+                          attr-dict `:` type($lhs) `,` type($rhs) }];
 
   // TODO: add a constant folder using pow[f] for cases, when
   //       the power argument is exactly representable in floating
   //       point type of the base.
 }
 
 #endif // MATH_OPS

mlir/test/Dialect/Math/ops.mlir

func.func @trunc(%f: f32, %v: vector<4xf32>, %t: tensor<4x4x?xf32>) {
   // CHECK: %{{.*}} = math.trunc %[[V]] : vector<4xf32>
   %1 = math.trunc %v : vector<4xf32>
   // CHECK: %{{.*}} = math.trunc %[[T]] : tensor<4x4x?xf32>
   %2 = math.trunc %t : tensor<4x4x?xf32>
   return
 }
 
 // CHECK-LABEL: func @fastmath(
-// CHECK-SAME:             %[[F:.*]]: f32, %[[V:.*]]: vector<4xf32>, %[[T:.*]]: tensor<4x4x?xf32>)
-func.func @fastmath(%f: f32, %v: vector<4xf32>, %t: tensor<4x4x?xf32>) {
-  // CHECK: %{{.*}} = math.trunc %[[F]] fastmath<fast> : f32
+// CHECK-SAME:      %[[F:.*]]: f32, %[[I:.*]]: i32,
+// CHECK-SAME:      %[[V:.*]]: vector<4xf32>, %[[T:.*]]: tensor<4x4x?xf32>)
+func.func @fastmath(%f: f32, %i: i32, %v: vector<4xf32>, %t: tensor<4x4x?xf32>) {
+  // CHECK: math.trunc %[[F]] fastmath<fast> : f32
   %0 = math.trunc %f fastmath<fast> : f32
-  // CHECK: %{{.*}} = math.powf %[[V]], %[[V]] fastmath<fast> : vector<4xf32>
+  // CHECK: math.powf %[[V]], %[[V]] fastmath<fast> : vector<4xf32>
   %1 = math.powf %v, %v fastmath<reassoc,nnan,ninf,nsz,arcp,contract,afn> : vector<4xf32>
-  // CHECK: %{{.*}} = math.fma %[[T]], %[[T]], %[[T]] : tensor<4x4x?xf32>
+  // CHECK: math.fma %[[T]], %[[T]], %[[T]] : tensor<4x4x?xf32>
   %2 = math.fma %t, %t, %t fastmath<none> : tensor<4x4x?xf32>
-  // CHECK: %{{.*}} = math.absf %[[F]] fastmath<ninf> : f32
+  // CHECK: math.absf %[[F]] fastmath<ninf> : f32
   %3 = math.absf %f fastmath<ninf> : f32
+  // CHECK: math.fpowi %[[F]], %[[I]] fastmath<fast> : f32, i32
+  %4 = math.fpowi %f, %i fastmath<fast> : f32, i32
   return
 }