[mlir][math] Lower math.floor,ceil to libm

[Lewuathe]

Summary

Lower math.floor and math.ceil to libm

[ftynse]

mlir/test/Conversion/MathToLibm/convert-to-libm.mlir

346

Please add the newline.

[Lewuathe]

Add new line

[Lewuathe]

Remove unnecessary newline.

mlir/lib/Conversion/MathToLibm/MathToLibm.cpp

void mlir::populateMathToLibmConversionPatterns(
   patterns.add<ScalarOpToLibmCall<math::RoundOp>>(patterns.getContext(),
                                                   "roundf", "round", benefit);
   patterns.add<ScalarOpToLibmCall<math::CosOp>>(patterns.getContext(), "cosf",
                                                 "cos", benefit);
   patterns.add<ScalarOpToLibmCall<math::SinOp>>(patterns.getContext(), "sinf",
                                                 "sin", benefit);
   patterns.add<ScalarOpToLibmCall<math::Log1pOp>>(
       patterns.getContext(), "log1pf", "log1p", log1pBenefit.value_or(benefit));
+  patterns.add<ScalarOpToLibmCall<math::FloorOp>>(patterns.getContext(),
+                                                  "floorf", "floor", benefit);
+  patterns.add<ScalarOpToLibmCall<math::CeilOp>>(patterns.getContext(), "ceilf",
+                                                 "ceil", benefit);
 }
 
 namespace {
 struct ConvertMathToLibmPass
     : public ConvertMathToLibmBase<ConvertMathToLibmPass> {
   void runOnOperation() override;
 };
 } // namespace

mlir/test/Conversion/ComplexToLibm/convert-to-libm.mlir

 func.func @clog_caller(%float: complex<f32>, %double: complex<f64>) -> (complex<f32>, complex<f64>)  {
   // CHECK: %[[FLOAT_RESULT:.*]] = call @clogf(%[[FLOAT]])
   %float_result = complex.log %float : complex<f32>
   // CHECK: %[[DOUBLE_RESULT:.*]] = call @clog(%[[DOUBLE]])
   %double_result = complex.log %double : complex<f64>
   // CHECK: return %[[FLOAT_RESULT]], %[[DOUBLE_RESULT]]
   return %float_result, %double_result : complex<f32>, complex<f64>
 }
+

mlir/test/Conversion/MathToLibm/convert-to-libm.mlir

 // CHECK-DAG: @tanh(f64) -> f64
 // CHECK-DAG: @tanhf(f32) -> f32
 // CHECK-DAG: @round(f64) -> f64
 // CHECK-DAG: @roundf(f32) -> f32
 // CHECK-DAG: @cos(f64) -> f64
 // CHECK-DAG: @cosf(f32) -> f32
 // CHECK-DAG: @sin(f64) -> f64
 // CHECK-DAG: @sinf(f32) -> f32
+// CHECK-DAG: @floor(f64) -> f64
+// CHECK-DAG: @floorf(f32) -> f32
+// CHECK-DAG: @ceil(f64) -> f64
+// CHECK-DAG: @ceilf(f32) -> f32
 
 // CHECK-LABEL: func @atan_caller
 // CHECK-SAME: %[[FLOAT:.*]]: f32
 // CHECK-SAME: %[[DOUBLE:.*]]: f64
 // CHECK-SAME: %[[HALF:.*]]: f16
 // CHECK-SAME: %[[BFLOAT:.*]]: bf16
 func.func @atan_caller(%float: f32, %double: f64, %half: f16, %bfloat: bf16) -> (f32, f64, f16, bf16)  {
   // CHECK: %[[FLOAT_RESULT:.*]] = call @atanf(%[[FLOAT]]) : (f32) -> f32

 // CHECK-SAME: %[[DOUBLE:.*]]: f64
 func.func @log1p_caller(%float: f32, %double: f64) -> (f32, f64)  {
   // CHECK-DAG: %[[FLOAT_RESULT:.*]] = call @log1pf(%[[FLOAT]]) : (f32) -> f32
   %float_result = math.log1p %float : f32
   // CHECK-DAG: %[[DOUBLE_RESULT:.*]] = call @log1p(%[[DOUBLE]]) : (f64) -> f64
   %double_result = math.log1p %double : f64
   // CHECK: return %[[FLOAT_RESULT]], %[[DOUBLE_RESULT]]
   return %float_result, %double_result : f32, f64
-}
+}
+
+// CHECK-LABEL: func @floor_caller
+// CHECK-SAME: %[[FLOAT:.*]]: f32
+// CHECK-SAME: %[[DOUBLE:.*]]: f64
+func.func @floor_caller(%float: f32, %double: f64) -> (f32, f64)  {
+  // CHECK-DAG: %[[FLOAT_RESULT:.*]] = call @floorf(%[[FLOAT]]) : (f32) -> f32
+  %float_result = math.floor %float : f32
+  // CHECK-DAG: %[[DOUBLE_RESULT:.*]] = call @floor(%[[DOUBLE]]) : (f64) -> f64
+  %double_result = math.floor %double : f64
+  // CHECK: return %[[FLOAT_RESULT]], %[[DOUBLE_RESULT]]
+  return %float_result, %double_result : f32, f64
+}
+
+// CHECK-LABEL: func @ceil_caller
+// CHECK-SAME: %[[FLOAT:.*]]: f32
+// CHECK-SAME: %[[DOUBLE:.*]]: f64
+func.func @ceil_caller(%float: f32, %double: f64) -> (f32, f64)  {
+  // CHECK-DAG: %[[FLOAT_RESULT:.*]] = call @ceilf(%[[FLOAT]]) : (f32) -> f32
+  %float_result = math.ceil %float : f32
+  // CHECK-DAG: %[[DOUBLE_RESULT:.*]] = call @ceil(%[[DOUBLE]]) : (f64) -> f64
+  %double_result = math.ceil %double : f64
+  // CHECK: return %[[FLOAT_RESULT]], %[[DOUBLE_RESULT]]
+  return %float_result, %double_result : f32, f64
+}