[CIR] Add cir::UnaryOp operation

For now covering increment/decrement.

Author: cmarcelo

clang/include/clang/CIR/Dialect/IR/CIROps.td

@@ -547,6 +547,53 @@ def ScopeOp : CIR_Op<"scope", [DeclareOpInterfaceMethods<RegionBranchOpInterface
   ];
 }
 
+//===----------------------------------------------------------------------===//
+// UnaryOp
+//===----------------------------------------------------------------------===//
+
+def UnaryOpKind_Inc : I32EnumAttrCase<"Inc", 1, "inc">;
+def UnaryOpKind_Dec : I32EnumAttrCase<"Dec", 2, "dec">;
+
+def UnaryOpKind : I32EnumAttr<
+    "UnaryOpKind",
+    "unary operation kind",
+    [UnaryOpKind_Inc,
+     UnaryOpKind_Dec]> {
+  let cppNamespace = "::mlir::cir";
+}
+
+// FIXME: NoSideEffect won't work when we add overloading.
+def UnaryOp : CIR_Op<"unary",
+                     [NoSideEffect,
+                      SameOperandsAndResultType]> {
+  let summary = "Unary operations";
+  let description = [{
+    `cir.unary` performs the unary operation according to
+    the specified opcode kind: [inc, dec].
+
+    Note for inc and dec: the operation corresponds only to the
+    addition/subtraction, its input is expect to come from a load
+    and the result to be used by a corresponding store.
+
+    It requires one input operand and has one result, both types
+    should be the same.
+
+    ```mlir
+    %7 = cir.unary(inc, %1) : i32 -> i32
+    %8 = cir.unary(dec, %2) : i32 -> i32
+    ```
+  }];
+
+  let results = (outs AnyType:$result);
+  let arguments = (ins Arg<UnaryOpKind, "unary op kind">:$kind, Arg<AnyType>:$input);
+
+  let assemblyFormat = [{
+      `(` $kind `,` $input `)` `:` type($input) `,` type($result) attr-dict
+  }];
+
+  let hasVerifier = 1;
+}
+
 //===----------------------------------------------------------------------===//
 // BinOp
 //===----------------------------------------------------------------------===//

clang/lib/CIR/Dialect/IR/CIRDialect.cpp

@@ -1274,6 +1274,33 @@ FunctionType CallOp::getCalleeType() {
   return FunctionType::get(getContext(), getOperandTypes(), getResultTypes());
 }
 
+//===----------------------------------------------------------------------===//
+// UnaryOp
+//===----------------------------------------------------------------------===//
+
+LogicalResult UnaryOp::verify() {
+  switch (getKind()) {
+  case cir::UnaryOpKind::Inc:
+    LLVM_FALLTHROUGH;
+  case cir::UnaryOpKind::Dec: {
+    // TODO: Consider looking at the memory interface instead of LoadOp/StoreOp.
+    auto loadOp = getInput().getDefiningOp<cir::LoadOp>();
+    if (!loadOp)
+      return emitOpError() << "requires input to be defined by a memory load";
+
+    for (const auto user : getResult().getUsers()) {
+      auto storeOp = dyn_cast<cir::StoreOp>(user);
+      if (storeOp && storeOp.getAddr() == loadOp.getAddr())
+        return success();
+    }
+    return emitOpError() << "requires result to be used by a memory store "
+                            "to the same address as the input memory load";
+  }
+  }
+
+  llvm_unreachable("Unknown UnaryOp kind?");
+}
+
 //===----------------------------------------------------------------------===//
 // CIR defined traits
 //===----------------------------------------------------------------------===//

clang/test/CIR/IR/invalid.cir

@@ -198,3 +198,26 @@ module {
 module {
   cir.global "public" internal @v = 3 : i32 // expected-error {{public visibility not allowed with 'internal' linkage}}
 }
+
+// -----
+
+cir.func @unary0() {
+  %0 = cir.alloca i32, cir.ptr <i32>, ["a", cinit] {alignment = 4 : i64}
+  %1 = cir.cst(2 : i32) : i32
+
+  %3 = cir.unary(inc, %1) : i32, i32 // expected-error {{'cir.unary' op requires input to be defined by a memory load}}
+  cir.store %3, %0 : i32, cir.ptr <i32>
+  cir.return
+}
+
+// -----
+
+cir.func @unary1() {
+  %0 = cir.alloca i32, cir.ptr <i32>, ["a", cinit] {alignment = 4 : i64}
+  %1 = cir.cst(2 : i32) : i32
+  cir.store %1, %0 : i32, cir.ptr <i32>
+
+  %2 = cir.load %0 : cir.ptr <i32>, i32
+  %3 = cir.unary(dec, %2) : i32, i32 //  // expected-error {{'cir.unary' op requires result to be used by a memory store to the same address as the input memory load}}
+  cir.return
+}