[MLIR] Add dialect prefix to all operations from Math

[andidr]

Summary

Prefix all operations from the ODS of the Math dialect with Math_
in order to avoid name clashes when including MathOps.td in other
TableGen files (e.g., for FloatUnaryOp, which also exists in
Standard).

[jpienaar]

Thanks!

[xgupta]

@andidr If you don't commit access yet, you need to share your name + email address so someone else can commit it.

[andidr]

Not sure why some of the unit tests fail. To me this looks unrelated to the patch. Is there any way to trigger re-running the tests?

[akuegel]

In D103248#2789176, @andidr wrote:

Not sure why some of the unit tests fail. To me this looks unrelated to the patch. Is there any way to trigger re-running the tests?

You could upload a new diff (e.g. with sync to HEAD) to the review, that should trigger re-running the tests.

[andidr]

Rebased diff to HEAD to trigger re-execution of tests.

[andidr]

The build now to fails for a different reason:

fatal: Unable to create 'C:/ws/w32-1/llvm-project/premerge-checks/.git/index.lock': File exists.

This looks like a broken build script or missing cleanup routine to me.

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

 //===- MathOps.td - Math op definitions --------------------*- tablegen -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef MATH_OPS
 #define MATH_OPS
 
 include "mlir/Dialect/Math/IR/MathBase.td"
 include "mlir/Interfaces/VectorInterfaces.td"
 include "mlir/Interfaces/SideEffectInterfaces.td"
 
-class MathOp<string mnemonic, list<OpTrait> traits = []>
+class Math_Op<string mnemonic, list<OpTrait> traits = []>
     : Op<Math_Dialect, mnemonic, traits # [NoSideEffect]>;
 
-class FloatUnaryOp<string mnemonic, list<OpTrait> traits = []> :
-    MathOp<mnemonic, traits #
+class Math_FloatUnaryOp<string mnemonic, list<OpTrait> traits = []> :
+    Math_Op<mnemonic, traits #
     [DeclareOpInterfaceMethods<VectorUnrollOpInterface>,
     SameOperandsAndResultType] # ElementwiseMappable.traits> {
   let arguments = (ins FloatLike:$operand);
 
   let results = (outs FloatLike:$result);
 
   let assemblyFormat = "$operand attr-dict `:` type($result)";
 }
 
-class FloatBinaryOp<string mnemonic, list<OpTrait> traits = []> :
-    MathOp<mnemonic, traits # [
+class Math_FloatBinaryOp<string mnemonic, list<OpTrait> traits = []> :
+    Math_Op<mnemonic, traits # [
     DeclareOpInterfaceMethods<VectorUnrollOpInterface>,
     SameOperandsAndResultType] # ElementwiseMappable.traits> {
   let arguments = (ins FloatLike:$lhs, FloatLike:$rhs);
   let results = (outs FloatLike:$result);
 
   let assemblyFormat = "$lhs `,` $rhs attr-dict `:` type($result)";
 }
 
 //===----------------------------------------------------------------------===//
 // AtanOp
 //===----------------------------------------------------------------------===//
 
-def AtanOp : FloatUnaryOp<"atan">{
+def Math_AtanOp : Math_FloatUnaryOp<"atan">{
   let summary = "arcus tangent of the given value";
   let description = [{
     Syntax:
 
     ```
     operation ::= ssa-id `=` `math.atan` ssa-use `:` type
     ```
 
let description = [{
     ```
   }];
 }
 
 //===----------------------------------------------------------------------===//
 // Atan2Op
 //===----------------------------------------------------------------------===//
 
-def Atan2Op : FloatBinaryOp<"atan2">{
+def Math_Atan2Op : Math_FloatBinaryOp<"atan2">{
   let summary = "2-argument arcus tangent of the given values";
   let description = [{
     Syntax:
 
     ```
     operation ::= ssa-id `=` `math.atan2` ssa-use `,` ssa-use `:` type
     ```
 
let description = [{
     ```
   }];
 }
 
 //===----------------------------------------------------------------------===//
 // CosOp
 //===----------------------------------------------------------------------===//
 
-def CosOp : FloatUnaryOp<"cos"> {
+def Math_CosOp : Math_FloatUnaryOp<"cos"> {
   let summary = "cosine of the specified value";
   let description = [{
     Syntax:
 
     ```
     operation ::= ssa-id `=` `math.cos` ssa-use `:` type
     ```
 
let description = [{
     ```
   }];
 }
 
 //===----------------------------------------------------------------------===//
 // SinOp
 //===----------------------------------------------------------------------===//
 
-def SinOp : FloatUnaryOp<"sin"> {
+def Math_SinOp : Math_FloatUnaryOp<"sin"> {
   let summary = "sine of the specified value";
   let description = [{
     Syntax:
 
     ```
     operation ::= ssa-id `=` `math.sin` ssa-use `:` type
     ```
 
def Math_SinOp : Math_FloatUnaryOp<"sin"> {
   }];
 }
 
 
 //===----------------------------------------------------------------------===//
 // ExpOp
 //===----------------------------------------------------------------------===//
 
-def ExpOp : FloatUnaryOp<"exp"> {
+def Math_ExpOp : Math_FloatUnaryOp<"exp"> {
   let summary = "base-e exponential of the specified value";
   let description = [{
     Syntax:
 
     ```
     operation ::= ssa-id `=` `math.exp` ssa-use `:` type
     ```
 
let description = [{
     ```
   }];
 }
 
 //===----------------------------------------------------------------------===//
 // Exp2Op
 //===----------------------------------------------------------------------===//
 
-def Exp2Op : FloatUnaryOp<"exp2"> {
+def Math_Exp2Op : Math_FloatUnaryOp<"exp2"> {
   let summary = "base-2 exponential of the specified value";
 
   let description = [{
     Syntax:
 
     ```
     operation ::= ssa-id `=` `math.exp2` ssa-use `:` type
     ```
let description = [{
     ```
   }];
 }
 
 //===----------------------------------------------------------------------===//
 // ExpM1Op
 //===----------------------------------------------------------------------===//
 
-def ExpM1Op : FloatUnaryOp<"expm1"> {
+def Math_ExpM1Op : Math_FloatUnaryOp<"expm1"> {
   let summary = "base-e exponential of the specified value minus 1";
   let description = [{
     Syntax:
 
     ```
     operation ::= ssa-id `=` `math.expm1` ssa-use `:` type
     ```
 
let description = [{
     ```
   }];
 }
 
 //===----------------------------------------------------------------------===//
 // LogOp
 //===----------------------------------------------------------------------===//
 
-def LogOp : FloatUnaryOp<"log"> {
+def Math_LogOp : Math_FloatUnaryOp<"log"> {
   let summary = "base-e logarithm of the specified value";
 
   let description = [{
     Computes the base-e logarithm of the given value. It takes one operand and
     returns one result of the same type.
 
     Example:
 
     ```mlir
     %y = math.log %x : f64
     ```
   }];
 }
 
 //===----------------------------------------------------------------------===//
 // Log10Op
 //===----------------------------------------------------------------------===//
 
-def Log10Op : FloatUnaryOp<"log10"> {
+def Math_Log10Op : Math_FloatUnaryOp<"log10"> {
   let summary = "base-10 logarithm of the specified value";
 
   let description = [{
     Computes the base-10 logarithm of the given value. It takes one operand and
     returns one result of the same type.
 
     Example:
 
     ```mlir
     %y = math.log10 %x : f64
     ```
   }];
 }
 
 //===----------------------------------------------------------------------===//
 // Log1pOp
 //===----------------------------------------------------------------------===//
 
-def Log1pOp : FloatUnaryOp<"log1p"> {
+def Math_Log1pOp : Math_FloatUnaryOp<"log1p"> {
   let summary = "Computes the natural logarithm of one plus the given value";
 
   let description = [{
     Computes the base-e logarithm of one plus the given value. It takes one
     operand and returns one result of the same type.
 
     log1p(x) := log(1 + x)
 
     Example:
 
     ```mlir
     %y = math.log1p %x : f64
     ```
   }];
 }
 
 //===----------------------------------------------------------------------===//
 // Log2Op
 //===----------------------------------------------------------------------===//
 
-def Log2Op : FloatUnaryOp<"log2"> {
+def Math_Log2Op : Math_FloatUnaryOp<"log2"> {
   let summary = "base-2 logarithm of the specified value";
 
   let description = [{
     Computes the base-2 logarithm of the given value. It takes one operand and
     returns one result of the same type.
 
     Example:
 
     ```mlir
     %y = math.log2 %x : f64
     ```
   }];
 }
 
 //===----------------------------------------------------------------------===//
 // PowFOp
 //===----------------------------------------------------------------------===//
 
-def PowFOp : FloatBinaryOp<"powf"> {
+def Math_PowFOp : Math_FloatBinaryOp<"powf"> {
   let summary = "floating point raised to the power of operation";
   let description = [{
     Syntax:
 
     ```
     operation ::= ssa-id `=` `math.powf` ssa-use `,` ssa-use `:` type
     ```
 
let description = [{
     ```
   }];
 }
 
 //===----------------------------------------------------------------------===//
 // RsqrtOp
 //===----------------------------------------------------------------------===//
 
-def RsqrtOp : FloatUnaryOp<"rsqrt"> {
+def Math_RsqrtOp : Math_FloatUnaryOp<"rsqrt"> {
   let summary = "reciprocal of sqrt (1 / sqrt of the specified value)";
   let description = [{
     The `rsqrt` operation computes the reciprocal of the square root. 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.
   }];
 }
 
 //===----------------------------------------------------------------------===//
 // SqrtOp
 //===----------------------------------------------------------------------===//
 
-def SqrtOp : FloatUnaryOp<"sqrt"> {
+def Math_SqrtOp : Math_FloatUnaryOp<"sqrt"> {
   let summary = "sqrt of the specified value";
   let description = [{
     The `sqrt` operation computes the square root. 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
     // Scalar square root value.
     %a = math.sqrt %b : f64
     // SIMD vector element-wise square root value.
     %f = math.sqrt %g : vector<4xf32>
     // Tensor element-wise square root value.
     %x = math.sqrt %y : tensor<4x?xf32>
     ```
   }];
 }
 
 //===----------------------------------------------------------------------===//
 // TanhOp
 //===----------------------------------------------------------------------===//
 
-def TanhOp : FloatUnaryOp<"tanh"> {
+def Math_TanhOp : Math_FloatUnaryOp<"tanh"> {
   let summary = "hyperbolic tangent of the specified value";
   let description = [{
     Syntax:
 
     ```
     operation ::= ssa-id `=` `std.tanh` ssa-use `:` type
     ```