Introduce OpenQASM 3 (OQ3) dialect

docs/variable-lowering.rst

@@ -49,15 +49,15 @@ identifies a location in memory and each reference or assignment to that
 variables reads or writes that location.
 
 -  Variables are declared by the QUIR operation
-   ``quir.declare_variable`` and identified as `MLIR
+   ``oq3.declare_variable`` and identified as `MLIR
    symbols <https://mlir.llvm.org/docs/SymbolsAndSymbolTables/>`__.
 -  Each reference to a variable is modeled as an operation
-   ``quir.use_variable`` that returns the variables value at that point.
--  The operation ``quir.assign_variable`` updates the variable’s value
+   ``oq3.use_variable`` that returns the variables value at that point.
+-  The operation ``oq3.assign_variable`` updates the variable’s value
    (visible from that operation forward until a subsequent
-   ``quir.assign_variable`` that operates on the same variable).
--  Both ``quir.use_variable`` and ``quir.assign_variable`` refer the
-   MLIR symbol defined by the operations ``quir.declare_variable`` (the
+   ``oq3.assign_variable`` that operates on the same variable).
+-  Both ``oq3.use_variable`` and ``oq3.assign_variable`` refer the
+   MLIR symbol defined by the operations ``oq3.declare_variable`` (the
    symbol’s name is a string).
 
 As an example, the OpenQASM 3 statement ``a = a ^ b`` (with ``a`` and
@@ -66,10 +66,10 @@ for clarity):
 
 ::
 
-      %0 = quir.use_variable @a
-      %1 = quir.use_variable @b
+      %0 = oq3.use_variable @a
+      %1 = oq3.use_variable @b
       %2 = quir.cbit_xor %s02, %s13
-      quir.assign_variable @a = %2
+      oq3.assign_variable @a = %2
 
 Variable scoping is not supported yet (there is only the global scope). Adding
 support is future work.
@@ -99,7 +99,7 @@ Best-Effort SSA Transformation
 The
 `VariableEliminationPass <https://github.com/Qiskit/qss-compiler/blob/main/lib/Dialect/QUIR/Transforms/VariableElimination.cpp>`__
 reuses the scalar-replacement pass from MLIR’s affine dialect to
-replace instances of `quir.use_variable` with the MLIR Value previously
+replace instances of `oq3.use_variable` with the MLIR Value previously
 assigned to the respective variable, in many cases. Noteably, that code
 does not perform a complete SSA transformation and variable assignment
 and use around control flow will be left as memory operations. The
@@ -108,8 +108,8 @@ and use around control flow will be left as memory operations. The
 Lowering to Memory Operations
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
-The operations ``quir.declare_variable``, ``quir.use_variable``, and
-``quir.assign_variable`` are converted to MLIR’s ``memref`` and
+The operations ``oq3.declare_variable``, ``oq3.use_variable``, and
+``oq3.assign_variable`` are converted to MLIR’s ``memref`` and
 ``affine`` dialects. Each variable declaration is turned into a global
 variable (``memref.global``) and variable reads/writes are converted
 into ``load`` and ``store`` operations from the ``affine`` dialect (only

include/Conversion/OQ3ToStandard/OQ3ToStandard.h

@@ -0,0 +1,43 @@
+//===- OQ3ToStandard.h - OpenQASM 3 to Standard patterns --------*- C++ -*-===//
+//
+// (C) Copyright IBM 2023.
+//
+// Any modifications or derivative works of this code must retain this
+// copyright notice, and modified files need to carry a notice indicating
+// that they have been altered from the originals.
+//
+//===----------------------------------------------------------------------===//
+///
+/// This file implements patterns to convert OpenQASM 3 to Standard dialect.
+///
+//===----------------------------------------------------------------------===//
+
+#ifndef CONVERSION_OQ3TOSTANDARD_OQ3TOSTANDARD_H_
+#define CONVERSION_OQ3TOSTANDARD_OQ3TOSTANDARD_H_
+
+#include "Dialect/OQ3/IR/OQ3Types.h"
+
+#include "mlir/IR/BuiltinTypes.h"
+#include "mlir/Transforms/DialectConversion.h"
+
+namespace mlir::oq3 {
+template <typename OQ3Op>
+class OQ3ToStandardConversion : public OpConversionPattern<OQ3Op> {
+public:
+  OQ3ToStandardConversion(MLIRContext *context, TypeConverter &typeConverter,
+                          PatternBenefit benefit = 1)
+      : OpConversionPattern<OQ3Op>(typeConverter, context, benefit),
+        typeConverter(typeConverter) {}
+
+protected:
+  TypeConverter &typeConverter;
+};
+
+// Appends to a pattern list additional patterns for translating OpenQASM 3
+// ops to Standard ops.
+void populateOQ3ToStandardConversionPatterns(
+    TypeConverter &typeConverter, RewritePatternSet &patterns,
+    bool includeBitmapOperationPatterns = true);
+}; // namespace mlir::oq3
+
+#endif // CONVERSION_OQ3TOSTANDARD_OQ3TOSTANDARD_H_

include/Dialect/CMakeLists.txt

@@ -4,6 +4,7 @@
 # copyright notice, and modified files need to carry a notice indicating
 # that they have been altered from the originals.
 
+add_subdirectory(OQ3)
 add_subdirectory(QUIR)
 add_subdirectory(Pulse)
 add_subdirectory(QCS)

include/Dialect/OQ3/CMakeLists.txt

@@ -0,0 +1,7 @@
+# (C) Copyright IBM 2023.
+#
+# Any modifications or derivative works of this code must retain this
+# copyright notice, and modified files need to carry a notice indicating
+# that they have been altered from the originals.
+
+add_subdirectory(IR)

include/Dialect/OQ3/IR/CMakeLists.txt

@@ -0,0 +1,14 @@
+# (C) Copyright IBM 2023.
+#
+# Any modifications or derivative works of this code must retain this
+# copyright notice, and modified files need to carry a notice indicating
+# that they have been altered from the originals.
+
+add_mlir_dialect(OQ3Ops oq3)
+qssc_add_mlir_doc(OQ3Ops OQ3Ops generated/Dialect/OQ3/ -gen-dialect-doc)
+
+set(LLVM_TARGET_DEFINITIONS OQ3Dialect.td)
+
+set(LLVM_TARGET_DEFINITIONS OQ3Patterns.td)
+mlir_tablegen(OQ3Patterns.inc -gen-rewriters)
+add_public_tablegen_target(MLIROQ3PatternsIncGen)

include/Dialect/OQ3/IR/OQ3AngleOps.td

@@ -0,0 +1,103 @@
+//===- OQ3AngleOps.td - OpenQASM 3 angle ops --------*- tablegen --------*-===//
+//
+// (C) Copyright IBM 2023.
+//
+// Any modifications or derivative works of this code must retain this
+// copyright notice, and modified files need to carry a notice indicating
+// that they have been altered from the originals.
+//
+//===----------------------------------------------------------------------===//
+///
+/// This is the operation definition file for OpenQASM 3 operations on
+/// angles.
+///
+//===----------------------------------------------------------------------===//
+
+#ifndef OQ3_ANGLE_OPS
+#define OQ3_ANGLE_OPS
+
+include "Dialect/OQ3/IR/OQ3Base.td"
+
+class OQ3_BinaryAngleOp<string mnemonic, list<Trait> traits = []> :
+  OQ3_BinaryOp<mnemonic, !listconcat(traits, [SameOperandsAndResultType])> {
+    let arguments = (ins AnyAngle:$lhs, AnyAngle:$rhs);
+    let results = (outs AnyAngle:$result);
+    let assemblyFormat = [{
+        attr-dict $lhs `,` $rhs `:` type($result)
+    }];
+}
+
+class OQ3_BinaryCmpOp<string mnemonic, list<Trait> traits = []> :
+  OQ3_BinaryOp<mnemonic, !listconcat(traits, [SameTypeOperands])> {
+    let results = (outs I1:$result);
+    let assemblyFormat = [{
+        attr-dict $lhs `,` $rhs `:` type($lhs) `->` type($result)
+    }];
+
+    let verifier = [{
+        std::vector predicates = { "eq", "ne", "slt", "sle", "sgt", "sge", "ult", "ule", "ugt", "uge" };
+
+        if (std::find(predicates.begin(), predicates.end(), this->predicate()) != predicates.end())
+            return success();
+        else
+            return emitOpError("requires predicate \"eq\", \"ne\", \"slt\", \"sle\", \"sgt\", \"sge\", \"ult\", \"ule\", \"ugt\", \"uge\"");
+    }];
+}
+
+// -----
+
+def OQ3_AngleAddOp : OQ3_BinaryAngleOp<"angle_add"> {
+    let summary = "Add two angles";
+    let description = [{
+        The `oq3.angle_add` operation takes two angle operands and returns one angle
+        result, which is the sum of the two operands. All angle operations are performed
+        over the interval [0,2*pi).
+    }];
+}
+
+// -----
+
+def OQ3_AngleSubOp : OQ3_BinaryAngleOp<"angle_sub"> {
+    let summary = "Subtract two angles";
+    let description = [{
+        The `oq3.angle_sub` operation takes two angle operands and returns one angle
+        result, which is the difference of the two operands. All angle operations are performed
+        over the interval [0,2*pi).
+    }];
+}
+
+// -----
+
+def OQ3_AngleMulOp : OQ3_BinaryAngleOp<"angle_mul"> {
+    let summary = "Multiply two angles";
+    let description = [{
+        The `oq3.angle_mul` operation takes two angle operands and returns one angle
+        result, which is the multiplication of the two operands. All angle operations are performed
+        over the interval [0,2*pi).
+    }];
+}
+
+// -----
+
+def OQ3_AngleDivOp : OQ3_BinaryAngleOp<"angle_div"> {
+    let summary = "Divide two angles";
+    let description = [{
+        The `oq3.angle_div` operation takes two angle operands and returns one angle
+        result, which is the division of the two operands. All angle operations are performed
+        over the interval [0,2*pi).
+    }];
+}
+
+// -----
+
+def OQ3_AngleCmpOp : OQ3_BinaryCmpOp<"angle_cmp"> {
+    let summary = "Compare two angles";
+    let description = [{
+        The `oq3.angle_cmp` operation takes two angle operands and returns one boolean
+        result. All angle operations are performed over the interval [0,2*pi).
+    }];
+
+	let arguments = (ins StrAttr:$predicate, AnyAngle:$lhs, AnyAngle:$rhs);
+}
+
+#endif // OQ3_ANGLE_OPS

include/Dialect/OQ3/IR/OQ3ArithmeticOps.td

@@ -0,0 +1,36 @@
+//===- OQ3ArithmeticOps.td - OpenQASM 3 arithmetic ops -----*- tablegen -*-===//
+//
+// (C) Copyright IBM 2023.
+//
+// Any modifications or derivative works of this code must retain this
+// copyright notice, and modified files need to carry a notice indicating
+// that they have been altered from the originals.
+//
+//===----------------------------------------------------------------------===//
+///
+/// This is the definition file for the OpenQASM 3 dialect arithmetic
+/// operations.
+///
+//===----------------------------------------------------------------------===//
+
+#ifndef OQ3_ARITHMETIC_OPS
+#define OQ3_ARITHMETIC_OPS
+
+include "mlir/Interfaces/InferTypeOpInterface.td"
+
+class OQ3_ArithmeticUnaryOp<string mnemonic, list<Trait> traits = []> :
+      OQ3_UnaryOp<mnemonic,
+                  !listconcat(traits, [SameOperandsAndResultType])>;
+
+class OQ3_ArithmeticBinaryOp<string mnemonic, list<Trait> traits = []> :
+      OQ3_BinaryOp<mnemonic,
+                   !listconcat(traits,
+                               [NoSideEffect, SameOperandsAndResultType])> {
+    let arguments = (ins AnyClassical:$lhs, AnyClassical:$rhs);
+    let results = (outs AnyClassical:$result);
+    let assemblyFormat = [{
+        attr-dict $lhs `,` $rhs `:` `(` type($lhs) `,` type($rhs) `)` `->` type($result)
+    }];
+}
+
+#endif // OQ3_ARITHMETIC_OPS