Add RsqrtOp to LLVM dialect.

[akuegel]

Summary

Add a convenience Op Rsqrt which is 1 / sqrt.

Also add the SameOperandsAndResultType trait to the Log Op.

[herhut]

Feel free to remove the changes to log. But with your change it seems even less consistent than before.

This should be cleaned up, though.

mlir/include/mlir/Dialect/LLVMIR/LLVMOps.td

755

Hmm, these could all be UnaryIntrinsicsOp, no? Or am I missing something?

Not that you need to clean this up but as you touched this one, why not the others?

[ftynse]

I don't think this belongs to the LLVM dialect. LLVM IR does not have rsqrt as operation or intrinsics, so neither should the dialect. We can have it in a higher-level dialect that lowers to llvm.intr.sqrt (to introduce) and llvm.fdiv (already available). But this expansion should _not_ happen when converting from the LLVM dialect to LLVM IR, that mapping is intentionally kept trivial.

[akuegel]

Ok, seems we should not have this in the LLVM dialect, so I will abandon this.

mlir/include/mlir/Dialect/LLVMIR/LLVMOps.td

 }
 
 // Floating point binary operations.
 def LLVM_FAddOp : LLVM_ArithmeticOp<"fadd", "CreateFAdd">;
 def LLVM_FSubOp : LLVM_ArithmeticOp<"fsub", "CreateFSub">;
 def LLVM_FMulOp : LLVM_ArithmeticOp<"fmul", "CreateFMul">;
 def LLVM_FDivOp : LLVM_ArithmeticOp<"fdiv", "CreateFDiv">;
 def LLVM_FRemOp : LLVM_ArithmeticOp<"frem", "CreateFRem">;
+
+// Floating point unary operations.
 def LLVM_FNegOp : LLVM_UnaryArithmeticOp<"fneg", "CreateFNeg">;
 
+def LLVM_RsqrtOp : LLVM_Op<"rsqrt", [NoSideEffect, SameOperandsAndResultType]>,
+                   Arguments<(ins LLVM_Type:$in)>,
+                   Results<(outs LLVM_Type:$res)> {
+  let llvmBuilder = [{
+    llvm::Module *module = builder.GetInsertBlock()->getModule();
+    llvm::Function *fn = llvm::Intrinsic::getDeclaration(
+        module, llvm::Intrinsic::sqrt, {$in->getType()});
+    auto sqrt = builder.CreateCall(fn, {$in});
+    $res = builder.CreateFDiv(llvm::ConstantFP::get(sqrt->getType(), 1), sqrt);
+  }];
+  let parser = [{ return impl::parseOneResultSameOperandTypeOp(parser, result); }];
+  let printer = [{ mlir::impl::printOneResultOp(this->getOperation(), p); }];
+}
+
 // Memory-related operations.
 def LLVM_AllocaOp :
     LLVM_OneResultOp<"alloca">,
     Arguments<(ins LLVM_Type:$arraySize, OptionalAttr<I64Attr>:$alignment)> {
   string llvmBuilder = [{
     auto *alloca = builder.CreateAlloca(
       $_resultType->getPointerElementType(), $arraySize);
     if ($alignment.hasValue()) {

 def LLVM_FAbsOp : LLVM_UnaryIntrinsicOp<"fabs">;
 def LLVM_FCeilOp : LLVM_UnaryIntrinsicOp<"ceil">;
 def LLVM_CosOp : LLVM_UnaryIntrinsicOp<"cos">;
 def LLVM_CopySignOp : LLVM_BinarySameArgsIntrinsicOp<"copysign">;
 def LLVM_FMAOp : LLVM_TernarySameArgsIntrinsicOp<"fma">;
 def LLVM_FMulAddOp : LLVM_TernarySameArgsIntrinsicOp<"fmuladd">;
 def LLVM_SqrtOp : LLVM_UnaryIntrinsicOp<"sqrt">;
 
-def LLVM_LogOp : LLVM_Op<"intr.log", [NoSideEffect]>,
+def LLVM_LogOp : LLVM_Op<"intr.log", [NoSideEffect, SameOperandsAndResultType]>,
                    Arguments<(ins LLVM_Type:$in)>,
                    Results<(outs LLVM_Type:$res)> {
   let llvmBuilder = [{
     llvm::Module *module = builder.GetInsertBlock()->getModule();
     llvm::Function *fn = llvm::Intrinsic::getDeclaration(
         module, llvm::Intrinsic::log, {$in->getType()});
     $res = builder.CreateCall(fn, {$in});
   }];

mlir/test/Dialect/LLVMIR/roundtrip.mlir

 // CHECK:       %27 = llvm.fpext %arg1 : !llvm.float to !llvm.x86_fp80
 // CHECK-NEXT:  %28 = llvm.fpext %arg1 : !llvm.float to !llvm.fp128
   %27 = llvm.fpext %arg1 : !llvm.float to !llvm.x86_fp80
   %28 = llvm.fpext %arg1 : !llvm.float to !llvm.fp128
 
 // CHECK:  %29 = llvm.fneg %arg1 : !llvm.float
   %29 = llvm.fneg %arg1 : !llvm.float
 
+// Floating point unary operations.
+// CHECK:  %30 = llvm.rsqrt %arg1 : !llvm.float
+  %30 = llvm.rsqrt %arg1 : !llvm.float
+
 // CHECK:  llvm.return
   llvm.return
 }
 
 // An larger self-contained function.
 // CHECK-LABEL:func @foo(%arg0: !llvm.i32) -> !llvm<"{ i32, double, i32 }"> {
 func @foo(%arg0: !llvm.i32) -> !llvm<"{ i32, double, i32 }"> {
 // CHECK-NEXT:  %0 = llvm.mlir.constant(3 : i64) : !llvm.i32