[MLIR][Standard] Add `atan` to standard dialect

[jpienaar]

mlir/include/mlir/Dialect/StandardOps/IR/Ops.td

517

These need an update

[herhut]

Please fix the comment.

[frgossen]

Fix documentation

[mehdi_amini]

I can't find a discussion and rationale on Discourse, was this discussed?
LLVM does not have intrinsics for atan I believe, it is just a libcall: what is the tradeoff about adding it to standard here?

[bondhugula]

In D88091#2288191, @mehdi_amini wrote:

I can't find a discussion and rationale on Discourse, was this discussed?
LLVM does not have intrinsics for atan I believe, it is just a libcall: what is the tradeoff about adding it to standard here?

Standard ML dialects have an atan op - xla_hlo/mhlo has it and others at that level would too. In order to be able to lower such ops to ops on scalar values (either stemming from 0-d tensor types or inside nests) for mid/low-level backends and to canonicalize/simplify such ops like others, one would need an abstraction in the std dialect. (Otherwise, we'd have to jump from lmhlo to call's early or to the LLVM dialect straight from there?). As far as the LLVM dialect not having intrinsics for a std dialect op goes, that way, the LLVM dialect doesn't have intrinsics for our alloc's and dealloc's as well. We just lower them to llvm.call to malloc, aligned_alloc, and free. However, LLVM does have support for these libcalls in its TLI that allow a lot of detection and optimization around these.

[frgossen]

We do not intend to add a standard lowering for atan as there would be many possible approximations.
Like @bondhugula said, it helps us with the lowering from lmhlo to std where we can subsequently apply our approximation.
Sorry for the missing discussion on Discourse. Should I still post it?

[frgossen]

https://llvm.discourse.group/t/standard-add-atan2-to-the-standard-dialect/1837

mlir/include/mlir/Dialect/StandardOps/IR/Ops.td

def AssumeAlignmentOp : Std_Op<"assume_alignment"> {
   }];
   let arguments = (ins AnyMemRef:$memref,
                        Confined<I32Attr, [IntPositive]>:$alignment);
   let results = (outs);
 
   let assemblyFormat = "$memref `,` $alignment attr-dict `:` type($memref)";
 }
 
+//===----------------------------------------------------------------------===//
+// AtanOp
+//===----------------------------------------------------------------------===//
+
+def AtanOp : FloatUnaryOp<"atan", []>{
+  let summary = "arcus tangent of the given value";
+  let description = [{
+    Syntax:
+
+    ```
+    operation ::= ssa-id `=` `std.atan` ssa-use `:` type
+    ```
+
+    The `atan` operation computes the arcus tangent of a given value.  It takes
+    one operand and returns one result of the same type.  This type may be a
+    float scalar type, a vector whose element type is float, or a tensor of
+    floats.  It has no standard attributes.
+
+    Example:
+
+    ```mlir
+    // Arcus tangent of scalar value.
+    %a = atan %b : f64
+
+    // SIMD vector element-wise arcus tangent.
+    %f = atan %g : vector<4xf32>
+
+    // Tensor element-wise arcus tangent.
+    %x = atan %y : tensor<4x?xf8>
+    ```
+  }];
+}
+
+//===----------------------------------------------------------------------===//
+// AtomicRMWOp
+//===----------------------------------------------------------------------===//
+
 def AtomicRMWOp : Std_Op<"atomic_rmw", [
       AllTypesMatch<["value", "result"]>,
       TypesMatchWith<"value type matches element type of memref",
                      "memref", "value",
                      "$_self.cast<MemRefType>().getElementType()">
     ]> {
   let summary = "atomic read-modify-write operation";
   let description = [{
let description = [{
     %f = cos %g : vector<4xf32>
 
     // Tensor element-wise cosine value.
     %x = cos %y : tensor<4x?xf8>
     ```
   }];
 }
 
+//===----------------------------------------------------------------------===//
+// SinOp
+//===----------------------------------------------------------------------===//
+
 def SinOp : FloatUnaryOp<"sin"> {
   let summary = "sine of the specified value";
   let description = [{
     Syntax:
 
     ```
     operation ::= ssa-id `=` `std.sin` ssa-use `:` type
     ```
let description = [{
     %f = sin %g : vector<4xf32>
 
     // Tensor element-wise sine value.
     %x = sin %y : tensor<4x?xf8>
     ```
   }];
 }
 
-
 //===----------------------------------------------------------------------===//
 // DeallocOp
 //===----------------------------------------------------------------------===//
 
 def DeallocOp : Std_Op<"dealloc",
     [MemoryEffects<[MemFree]>, MemRefsNormalizable]> {
   let summary = "memory deallocation operation";
   let description = [{