[CIR] Refactor IntType constraints

xlauko · xlauko · commit 5b17612ae7a6 · 2025-04-28T14:14:51.000+02:00
diff --git a/clang/include/clang/CIR/Dialect/IR/CIROps.td b/clang/include/clang/CIR/Dialect/IR/CIROps.td
@@ -16,6 +16,7 @@
 
 include "clang/CIR/Dialect/IR/CIRDialect.td"
 include "clang/CIR/Dialect/IR/CIRTypes.td"
+include "clang/CIR/Dialect/IR/CIRTypeConstraints.td"
 include "clang/CIR/Dialect/IR/CIRAttrs.td"
 
 include "clang/CIR/Interfaces/ASTAttrInterfaces.td"
@@ -297,7 +298,7 @@ def ObjSizeOp : CIR_Op<"objsize", [Pure]> {
 
   let arguments = (ins CIR_PointerType:$ptr, SizeInfoType:$kind,
                    UnitAttr:$dynamic);
-  let results = (outs PrimitiveInt:$result);
+  let results = (outs CIR_IntType:$result);
 
   let assemblyFormat = [{
     `(`
@@ -333,7 +334,7 @@ def PtrDiffOp : CIR_Op<"ptr_diff", [Pure, SameTypeOperands]> {
     ```
   }];
 
-  let results = (outs PrimitiveInt:$result);
+  let results = (outs CIR_IntType:$result);
   let arguments = (ins CIR_PointerType:$lhs, CIR_PointerType:$rhs);
 
   let assemblyFormat = [{
@@ -361,7 +362,7 @@ def PtrStrideOp : CIR_Op<"ptr_stride",
     ```
   }];
 
-  let arguments = (ins CIR_PointerType:$base, PrimitiveInt:$stride);
+  let arguments = (ins CIR_PointerType:$base, CIR_IntType:$stride);
   let results = (outs CIR_PointerType:$result);
 
   let assemblyFormat = [{
@@ -492,7 +493,7 @@ def AllocaOp : CIR_Op<"alloca", [
   }];
 
   let arguments = (ins
-    Optional<PrimitiveInt>:$dynAllocSize,
+    Optional<CIR_IntType>:$dynAllocSize,
     TypeAttr:$allocaType,
     StrAttr:$name,
     UnitAttr:$init,
@@ -1033,7 +1034,7 @@ def ResumeOp : CIR_Op<"resume", [ReturnLike, Terminator,
   }];
 
   let arguments = (ins Optional<VoidPtr>:$exception_ptr,
-                       Optional<UInt32>:$type_id,
+                       Optional<CIR_UInt32>:$type_id,
                        UnitAttr:$rethrow);
   let assemblyFormat = [{
     ($rethrow^)?
@@ -1585,7 +1586,7 @@ class CIR_CountZerosBitOp<string mnemonic, TypeConstraint inputTy>
   }];
 }
 
-def BitClrsbOp : CIR_BitOp<"bit.clrsb", AnyTypeOf<[SInt32, SInt64]>> {
+def BitClrsbOp : CIR_BitOp<"bit.clrsb", CIR_SIntOfWidths<[32, 64]>> {
   let summary = "Get the number of leading redundant sign bits in the input";
   let description = [{
     Compute the number of leading redundant sign bits in the input integer.
@@ -1616,7 +1617,7 @@ def BitClrsbOp : CIR_BitOp<"bit.clrsb", AnyTypeOf<[SInt32, SInt64]>> {
   }];
 }
 
-def BitClzOp : CIR_CountZerosBitOp<"bit.clz", AnyTypeOf<[UInt16, UInt32, UInt64]>> {
+def BitClzOp : CIR_CountZerosBitOp<"bit.clz", CIR_UIntOfWidths<[16, 32, 64]>> {
   let summary = "Get the number of leading 0-bits in the input";
   let description = [{
     Compute the number of leading 0-bits in the input.
@@ -1641,7 +1642,7 @@ def BitClzOp : CIR_CountZerosBitOp<"bit.clz", AnyTypeOf<[UInt16, UInt32, UInt64]
   }];
 }
 
-def BitCtzOp : CIR_CountZerosBitOp<"bit.ctz", AnyTypeOf<[UInt16, UInt32, UInt64]>> {
+def BitCtzOp : CIR_CountZerosBitOp<"bit.ctz", CIR_UIntOfWidths<[16, 32, 64]>> {
   let summary = "Get the number of trailing 0-bits in the input";
   let description = [{
     Compute the number of trailing 0-bits in the input.
@@ -1667,7 +1668,7 @@ def BitCtzOp : CIR_CountZerosBitOp<"bit.ctz", AnyTypeOf<[UInt16, UInt32, UInt64]
   }];
 }
 
-def BitFfsOp : CIR_BitOp<"bit.ffs", AnyTypeOf<[SInt32, SInt64]>> {
+def BitFfsOp : CIR_BitOp<"bit.ffs", CIR_SIntOfWidths<[32, 64]>> {
   let summary = "Get the position of the least significant 1-bit of input";
   let description = [{
     Compute the position of the least significant 1-bit of the input.
@@ -1690,7 +1691,7 @@ def BitFfsOp : CIR_BitOp<"bit.ffs", AnyTypeOf<[SInt32, SInt64]>> {
   }];
 }
 
-def BitParityOp : CIR_BitOp<"bit.parity", AnyTypeOf<[UInt32, UInt64]>> {
+def BitParityOp : CIR_BitOp<"bit.parity", CIR_UIntOfWidths<[32, 64]>> {
   let summary = "Get the parity of input";
   let description = [{
     Compute the parity of the input. The parity of an integer is the number of
@@ -1713,7 +1714,7 @@ def BitParityOp : CIR_BitOp<"bit.parity", AnyTypeOf<[UInt32, UInt64]>> {
 }
 
 def BitPopcountOp
-    : CIR_BitOp<"bit.popcount", AnyTypeOf<[UInt16, UInt32, UInt64]>> {
+    : CIR_BitOp<"bit.popcount", CIR_UIntOfWidths<[16, 32, 64]>> {
   let summary = "Get the number of 1-bits in input";
   let description = [{
     Compute the number of 1-bits in the input.
@@ -1760,7 +1761,7 @@ def ByteswapOp : CIR_Op<"bswap", [Pure, SameOperandsAndResultType]> {
   }];
 
   let results = (outs CIR_IntType:$result);
-  let arguments = (ins AnyTypeOf<[UInt16, UInt32, UInt64]>:$input);
+  let arguments = (ins CIR_UIntOfWidths<[16, 32, 64]>:$input);
 
   let assemblyFormat = [{
     `(` $input `:` type($input) `)` `:` type($result) attr-dict
@@ -1792,7 +1793,7 @@ def RotateOp : CIR_Op<"rotate", [Pure, SameOperandsAndResultType]> {
   }];
 
   let results = (outs CIR_IntType:$result);
-  let arguments = (ins PrimitiveInt:$src, PrimitiveInt:$amt,
+  let arguments = (ins CIR_IntType:$src, CIR_IntType:$amt,
                        UnitAttr:$left);
 
   let assemblyFormat = [{
@@ -1821,8 +1822,8 @@ def BitReverseOp : CIR_Op<"bit_reverse", [Pure, SameOperandsAndResultType]> {
     ```
   }];
 
-  let arguments = (ins AnyTypeOf<[UInt8, UInt16, UInt32, UInt64]>:$src);
-  let results = (outs AnyTypeOf<[UInt8, UInt16, UInt32, UInt64]>:$result);
+  let arguments = (ins CIR_UIntOfWidths<[8, 16, 32, 64]>:$src);
+  let results = (outs CIR_UIntOfWidths<[8, 16, 32, 64]>:$result);
 
   let assemblyFormat = [{
     $src `:` type($result) attr-dict
@@ -1868,7 +1869,7 @@ def CmpThreeWayOp : CIR_Op<"cmp3way", [Pure, SameTypeOperands]> {
     ```
   }];
 
-  let results = (outs PrimitiveSInt:$result);
+  let results = (outs CIR_SIntType:$result);
   let arguments = (ins CIR_AnyType:$lhs, CIR_AnyType:$rhs,
                        CmpThreeWayInfoAttr:$info);
 
@@ -3134,7 +3135,7 @@ def VecInsertOp : CIR_Op<"vec.insert", [Pure,
     element is returned.
   }];
 
-  let arguments = (ins CIR_VectorType:$vec, AnyType:$value, PrimitiveInt:$index);
+  let arguments = (ins CIR_VectorType:$vec, AnyType:$value, CIR_IntType:$index);
   let results = (outs CIR_VectorType:$result);
 
   let assemblyFormat = [{
@@ -3161,7 +3162,7 @@ def VecExtractOp : CIR_Op<"vec.extract", [Pure,
     from a vector object.
   }];
 
-  let arguments = (ins CIR_VectorType:$vec, PrimitiveInt:$index);
+  let arguments = (ins CIR_VectorType:$vec, CIR_IntType:$index);
   let results = (outs CIR_AnyType:$result);
 
   let assemblyFormat = [{
@@ -4367,7 +4368,7 @@ def EhInflightOp : CIR_Op<"eh.inflight_exception"> {
 
   let arguments = (ins UnitAttr:$cleanup,
                        OptionalAttr<FlatSymbolRefArrayAttr>:$sym_type_list);
-  let results = (outs VoidPtr:$exception_ptr, UInt32:$type_id);
+  let results = (outs VoidPtr:$exception_ptr, CIR_UInt32:$type_id);
   let assemblyFormat = [{
     (`cleanup` $cleanup^)?
     ($sym_type_list^)?
@@ -4386,7 +4387,7 @@ def EhTypeIdOp : CIR_Op<"eh.typeid",
   }];
 
   let arguments = (ins FlatSymbolRefAttr:$type_sym);
-  let results = (outs UInt32:$type_id);
+  let results = (outs CIR_UInt32:$type_id);
   let assemblyFormat = [{
     $type_sym attr-dict
   }];
@@ -4469,7 +4470,7 @@ def MemCpyOp : CIR_MemOp<"libc.memcpy"> {
     ```
   }];
 
-  let arguments = !con(commonArgs, (ins PrimitiveUInt:$len));
+  let arguments = !con(commonArgs, (ins CIR_UIntType:$len));
 
   let assemblyFormat = [{
     $len `bytes` `from` $src `to` $dst attr-dict
@@ -4499,7 +4500,7 @@ def MemMoveOp : CIR_MemOp<"libc.memmove"> {
     ```
   }];
 
-  let arguments = !con(commonArgs, (ins PrimitiveUInt:$len));
+  let arguments = !con(commonArgs, (ins CIR_UIntType:$len));
 
   let assemblyFormat = [{
     $len `bytes` `from` $src `to` $dst attr-dict
@@ -4548,8 +4549,8 @@ def MemCpyInlineOp : CIR_MemOp<"memcpy_inline"> {
 
 def MemSetOp : CIR_Op<"libc.memset"> {
   let arguments = (ins Arg<VoidPtr, "", [MemWrite]>:$dst,
-                       SInt32:$val,
-                       PrimitiveUInt:$len);
+                       CIR_SInt32:$val,
+                       CIR_UIntType:$len);
   let summary = "Equivalent to libc's `memset`";
   let description = [{
     Given the CIR pointer, `dst`, `cir.libc.memset` will set the first `len`
@@ -4579,7 +4580,7 @@ def MemSetOp : CIR_Op<"libc.memset"> {
 
 def MemSetInlineOp : CIR_Op<"memset_inline"> {
   let arguments = (ins Arg<VoidPtr, "", [MemWrite]>:$dst,
-                       SInt32:$val,
+                       CIR_SInt32:$val,
                        I64Attr:$len);
   let summary = "Fill a block of memory with constant length without calling"
                 "any external function";
@@ -4612,8 +4613,8 @@ def MemChrOp : CIR_Op<"libc.memchr"> {
   // TODO: instead of using UInt64 for len, we could make it constrained on
   // size_t (64 or 32) and have a builder that does the right job.
   let arguments = (ins Arg<VoidPtr, "", [MemRead]>:$src,
-                       SInt32:$pattern,
-                       UInt64:$len);
+                       CIR_SInt32:$pattern,
+                       CIR_UInt64:$len);
   let summary = "libc's `memchr`";
   let results = (outs Res<VoidPtr, "">:$result);
 
@@ -4641,7 +4642,7 @@ def MemChrOp : CIR_Op<"libc.memchr"> {
 //===----------------------------------------------------------------------===//
 
 class FuncAddrBuiltinOp<string mnemonic> : CIR_Op<mnemonic, []> {
-  let arguments = (ins UInt32:$level);
+  let arguments = (ins CIR_UInt32:$level);
   let results = (outs Res<VoidPtr, "">:$result);
   let assemblyFormat = [{
     `(` $level `)` attr-dict
@@ -4951,10 +4952,10 @@ def ExpectOp : CIR_Op<"expect",
     where probability = $prob.
   }];
 
-  let arguments = (ins PrimitiveInt:$val,
-                       PrimitiveInt:$expected,
+  let arguments = (ins CIR_IntType:$val,
+                       CIR_IntType:$expected,
                        OptionalAttr<F64Attr>:$prob);
-  let results = (outs PrimitiveInt:$result);
+  let results = (outs CIR_IntType:$result);
   let assemblyFormat = [{
     `(` $val`,` $expected (`,` $prob^)? `)` `:` type($val) attr-dict
   }];
diff --git a/clang/include/clang/CIR/Dialect/IR/CIRTypeConstraints.td b/clang/include/clang/CIR/Dialect/IR/CIRTypeConstraints.td
@@ -0,0 +1,82 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+//
+// This file defines the CIR dialect type constraints.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef CLANG_CIR_DIALECT_IR_CIRTYPECONSTRAINTS_TD
+#define CLANG_CIR_DIALECT_IR_CIRTYPECONSTRAINTS_TD
+
+include "mlir/IR/Constraints.td"
+
+class CIR_IsTypePred<code type> : CPred<"::mlir::isa<" # type # ">($_self)">;
+
+class CIR_TypeBase<string type, string summary = "">
+    : Type<CIR_IsTypePred<type>, summary, type>;
+
+class CIR_CastSelfToType<string type, Pred pred>
+    : SubstLeaves<"$_self", "::mlir::cast<" # type # ">($_self)", pred>;
+
+class CIR_CastedSelfsToType<string type, list<Pred> preds>
+    : And<!foreach(pred, preds, CIR_CastSelfToType<type, pred>)>;
+
+class CIR_ConfinedType<Type type, list<Pred> preds, string summary = "">
+    : Type<And<[type.predicate, CIR_CastedSelfsToType<type.cppType, preds>]>,
+         summary, type.cppType>;
+
+//===----------------------------------------------------------------------===//
+// IntType predicates
+//===----------------------------------------------------------------------===//
+
+def CIR_AnyIntType : CIR_TypeBase<"::cir::IntType", "any integer type">;
+
+def CIR_UIntType : CIR_ConfinedType<CIR_AnyIntType, [
+    CPred<"$_self.isUnsigned()">], "Unsigned integer type">;
+
+def CIR_SIntType : CIR_ConfinedType<CIR_AnyIntType, [
+    CPred<"$_self.isSigned()">], "signed integer type">;
+
+class CIR_HasWidthPred<int width> : CPred<"$_self.getWidth() == " # width>;
+
+class CIR_IntOfWidthsPred<list<int> widths>
+    : Or<!foreach(width, widths, CIR_HasWidthPred<width>)>;
+
+class CIR_SIntOfWidths<list<int> widths>
+    : CIR_ConfinedType<CIR_SIntType, [CIR_IntOfWidthsPred<widths>],
+        "signed integer type of widths" # !interleave(widths, "/" )>;
+
+class CIR_UIntOfWidths<list<int> widths>
+    : CIR_ConfinedType<CIR_UIntType, [CIR_IntOfWidthsPred<widths>],
+        "unsigned integer type of widths" # !interleave(widths, "/" )>;
+
+class CIR_UInt<int width>
+    : CIR_ConfinedType<CIR_UIntType, [CIR_HasWidthPred<width>],
+        width # "-bit unsigned integer">,
+      BuildableType<"$_builder.getType<" # cppType # ">(" #
+        width # ", /*isSigned=*/false)">;
+
+def CIR_UInt1 : CIR_UInt<1>;
+def CIR_UInt8 : CIR_UInt<8>;
+def CIR_UInt16 : CIR_UInt<16>;
+def CIR_UInt32 : CIR_UInt<32>;
+def CIR_UInt64 : CIR_UInt<64>;
+
+class CIR_SInt<int width>
+    : CIR_ConfinedType<CIR_SIntType, [CIR_HasWidthPred<width>],
+        width # "-bit signed integer">,
+      BuildableType<"$_builder.getType<" # cppType # ">(" #
+        width # ", /*isSigned=*/true)">;
+
+def CIR_SInt1 : CIR_SInt<1>;
+def CIR_SInt8 : CIR_SInt<8>;
+def CIR_SInt16 : CIR_SInt<16>;
+def CIR_SInt32 : CIR_SInt<32>;
+def CIR_SInt64 : CIR_SInt<64>;
+
+#endif // CLANG_CIR_DIALECT_IR_CIRTYPECONSTRAINTS_TD
diff --git a/clang/include/clang/CIR/Dialect/IR/CIRTypes.td b/clang/include/clang/CIR/Dialect/IR/CIRTypes.td
