[fir] Remove obsolete fir.negf and fir.modf ops

[clementval]

Summary

fir.negf op is replaced by mlir.negf and
fir.modf is just deleted.

Co-authored-by: Jean Perier <[e-mail]>
Co-authored-by: Eric Schweitz <[e-mail]>

[kiranchandramohan]

LGTM.

[jeanPerier]

Patch LGTM, just pointing out that this work actually came from Kiran in https://github.com/flang-compiler/f18-llvm-project/pull/885 (My name tend to show up more than it should in fir-dev because of rebases). Thanks for the work there Kiran !

[clementval]

In D110932#3061428, @jeanPerier wrote:

Patch LGTM, just pointing out that this work actually came from Kiran in https://github.com/flang-compiler/f18-llvm-project/pull/885 (My name tend to show up more than it should in fir-dev because of rebases). Thanks for the work there Kiran !

Yeah sorry Kiran! It is hard to attribute authorship of those upstreaming patches sometimes.

flang/include/flang/Optimizer/Dialect/FIROps.td

class fir_UnaryArithmeticOp<string mnemonic, list<OpTrait> traits = []> :
       Results<(outs AnyType)> {
   let parser = [{
     return impl::parseOneResultSameOperandTypeOp(parser, result);
   }];
 
   let printer = [{ return printUnaryOp(this->getOperation(), p); }];
 }
 
-class RealUnaryArithmeticOp<string mnemonic, list<OpTrait> traits = []> :
-      fir_UnaryArithmeticOp<mnemonic, traits>,
-      Arguments<(ins AnyRealLike:$operand)>;
-
-def fir_NegfOp : RealUnaryArithmeticOp<"negf">;
-
-class RealArithmeticOp<string mnemonic, list<OpTrait> traits = []> :
-      fir_ArithmeticOp<mnemonic, traits>,
-      Arguments<(ins AnyRealLike:$lhs, AnyRealLike:$rhs)>;
-
-def fir_ModfOp : RealArithmeticOp<"modf">;
-
 def fir_ConstcOp : fir_Op<"constc", [NoSideEffect]> {
   let summary = "create a complex constant";
 
   let description = [{
     A complex constant. Similar to the standard dialect complex type, but this
     extension allows constants with APFloat values that are not supported in
     the standard dialect.
   }];

flang/lib/Lower/IntrinsicCall.cpp

mlir::Value IntrinsicLibrary::genConjg(mlir::Type resultType,
   assert(args.size() == 1);
   if (resultType != args[0].getType())
     llvm_unreachable("argument type mismatch");
 
   mlir::Value cplx = args[0];
   auto imag =
       Fortran::lower::ComplexExprHelper{builder, loc}.extractComplexPart(
           cplx, /*isImagPart=*/true);
-  auto negImag = builder.create<fir::NegfOp>(loc, imag);
+  auto negImag = builder.create<mlir::NegFOp>(loc, imag);
   return Fortran::lower::ComplexExprHelper{builder, loc}.insertComplexPart(
       cplx, negImag, /*isImagPart=*/true);
 }
 
 // DIM
 mlir::Value IntrinsicLibrary::genDim(mlir::Type resultType,
                                      llvm::ArrayRef<mlir::Value> args) {
   assert(args.size() == 2);
if (resultType.isa<mlir::IntegerType>()) {
     auto neg = builder.create<mlir::SubIOp>(loc, zero, abs);
     auto cmp = builder.create<mlir::CmpIOp>(loc, mlir::CmpIPredicate::slt,
                                             args[1], zero);
     return builder.create<mlir::SelectOp>(loc, cmp, neg, abs);
   }
   // TODO: Requirements when second argument is +0./0.
   auto zeroAttr = builder.getZeroAttr(resultType);
   auto zero = builder.create<mlir::ConstantOp>(loc, resultType, zeroAttr);
-  auto neg = builder.create<fir::NegfOp>(loc, abs);
+  auto neg = builder.create<mlir::NegFOp>(loc, abs);
   auto cmp = builder.create<mlir::CmpFOp>(loc, mlir::CmpFPredicate::OLT,
                                           args[1], zero);
   return builder.create<mlir::SelectOp>(loc, cmp, neg, abs);
 }
 
 // Compare two FIR values and return boolean result as i1.
 template <Extremum extremum, ExtremumBehavior behavior>
 static mlir::Value createExtremumCompare(mlir::Location loc,

flang/test/Fir/fir-ops.fir

 }
 
 // CHECK-LABEL: func @arith_real(
 // CHECK-SAME: [[VAL_169:%.*]]: f128, [[VAL_170:%.*]]: f128) -> f128 {
 func @arith_real(%a : f128, %b : f128) -> f128 {
 
 // CHECK: [[VAL_171:%.*]] = constant 1.0
 // CHECK: [[VAL_172:%.*]] = fir.convert [[VAL_171]] : (f32) -> f128
-// CHECK: [[VAL_173:%.*]] = fir.negf [[VAL_169]] : f128
+// CHECK: [[VAL_173:%.*]] = negf [[VAL_169]] : f128
 // CHECK: [[VAL_174:%.*]] = addf [[VAL_172]], [[VAL_173]] : f128
 // CHECK: [[VAL_175:%.*]] = subf [[VAL_174]], [[VAL_170]] : f128
 // CHECK: [[VAL_176:%.*]] = mulf [[VAL_173]], [[VAL_175]] : f128
 // CHECK: [[VAL_177:%.*]] = divf [[VAL_176]], [[VAL_169]] : f128
-// CHECK: [[VAL_178:%.*]] = fir.modf [[VAL_177]], [[VAL_170]] : f128
   %c1 = constant 1.0 : f32
   %0 = fir.convert %c1 : (f32) -> f128
-  %1 = fir.negf %a : f128
+  %1 = negf %a : f128
   %2 = addf %0, %1 : f128
   %3 = subf %2, %b : f128
   %4 = mulf %1, %3 : f128
   %5 = divf %4, %a : f128
-  %6 = fir.modf %5, %b : f128
-// CHECK: return [[VAL_178]] : f128
+// CHECK: return [[VAL_177]] : f128
 // CHECK: }
-  return %6 : f128
+  return %5 : f128
 }
 
 // CHECK-LABEL: func @arith_complex(
 // CHECK-SAME: [[VAL_179:%.*]]: !fir.complex<16>, [[VAL_180:%.*]]: !fir.complex<16>) -> !fir.complex<16> {
 func @arith_complex(%a : !fir.complex<16>, %b : !fir.complex<16>) -> !fir.complex<16> {
 // CHECK: [[VAL_181:%.*]] = fir.negc [[VAL_179]] : !fir.complex<16>
 // CHECK: [[VAL_182:%.*]] = fir.addc [[VAL_180]], [[VAL_181]] : !fir.complex<16>
 // CHECK: [[VAL_183:%.*]] = fir.subc [[VAL_182]], [[VAL_180]] : !fir.complex<16>