[CIR] Refactor VoidPtr constraint to CIR_VoidPtrType (llvm#1601)

Author: xlauko

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

@@ -1037,7 +1037,7 @@ def ResumeOp : CIR_Op<"resume", [ReturnLike, Terminator,
     ```
   }];
 
-  let arguments = (ins Optional<VoidPtr>:$exception_ptr,
+  let arguments = (ins Optional<CIR_VoidPtrType>:$exception_ptr,
                        Optional<CIR_UInt32>:$type_id,
                        UnitAttr:$rethrow);
   let assemblyFormat = [{
@@ -2661,7 +2661,7 @@ def VTTAddrPointOp : CIR_Op<"vtt.address_point",
   let arguments = (ins OptionalAttr<FlatSymbolRefAttr>:$name,
                        Optional<CIR_AnyType>:$sym_addr,
                        I32Attr:$offset);
-  let results = (outs Res<CIR_PointerType, "", []>:$addr);
+  let results = (outs CIR_PointerType:$addr);
 
   let assemblyFormat = [{
       ($name^)?
@@ -3114,7 +3114,7 @@ def GetMethodOp : CIR_Op<"get_method"> {
   }];
 
   let arguments = (ins CIR_MethodType:$method, RecordPtr:$object);
-  let results = (outs FuncPtr:$callee, VoidPtr:$adjusted_this);
+  let results = (outs FuncPtr:$callee, CIR_VoidPtrType:$adjusted_this);
 
   let assemblyFormat = [{
     $method `,` $object
@@ -4345,7 +4345,7 @@ def CatchParamOp : CIR_Op<"catch_param"> {
     ```
   }];
 
-  let arguments = (ins Optional<VoidPtr>:$exception_ptr,
+  let arguments = (ins Optional<CIR_VoidPtrType>:$exception_ptr,
                        OptionalAttr<CatchParamKind>:$kind);
   let results = (outs Optional<CIR_AnyType>:$param);
   let assemblyFormat = [{
@@ -4384,7 +4384,7 @@ def EhInflightOp : CIR_Op<"eh.inflight_exception"> {
 
   let arguments = (ins UnitAttr:$cleanup,
                        OptionalAttr<FlatSymbolRefArrayAttr>:$sym_type_list);
-  let results = (outs VoidPtr:$exception_ptr, CIR_UInt32:$type_id);
+  let results = (outs CIR_VoidPtrType:$exception_ptr, CIR_UInt32:$type_id);
   let assemblyFormat = [{
     (`cleanup` $cleanup^)?
     ($sym_type_list^)?
@@ -4462,9 +4462,10 @@ def CopyOp : CIR_Op<"copy",
 
 class CIR_MemOp<string mnemonic>
     : CIR_Op<mnemonic, [AllTypesMatch<["dst", "src"]>]> {
-  dag commonArgs = (ins Arg<VoidPtr, "", [MemWrite]>:$dst,
-      Arg<VoidPtr, "", [MemRead]>:$src);
-  let hasVerifier = 0;
+  dag commonArgs = (ins
+    Arg<CIR_VoidPtrType, "", [MemWrite]>:$dst,
+    Arg<CIR_VoidPtrType, "", [MemRead]>:$src
+  );
 }
 
 def MemCpyOp : CIR_MemOp<"libc.memcpy"> {
@@ -4581,7 +4582,7 @@ def MemSetOp : CIR_Op<"libc.memset"> {
   }];
 
   let arguments = (ins
-    Arg<VoidPtr, "", [MemWrite]>:$dst,
+    Arg<CIR_VoidPtrType, "", [MemWrite]>:$dst,
     CIR_SInt32:$val,
     CIR_AnyFundamentalUIntType:$len
   );
@@ -4615,7 +4616,7 @@ def MemSetInlineOp : CIR_Op<"memset_inline"> {
   }];
 
   let arguments = (ins
-    Arg<VoidPtr, "", [MemWrite]>:$dst,
+    Arg<CIR_VoidPtrType, "", [MemWrite]>:$dst,
     CIR_SInt32:$val,
     I64Attr:$len
   );
@@ -4647,12 +4648,12 @@ 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,
+    Arg<CIR_VoidPtrType, "", [MemRead]>:$src,
     CIR_SInt32:$pattern,
     CIR_UInt64:$len
   );
 
-  let results = (outs Res<VoidPtr, "">:$result);
+  let results = (outs CIR_VoidPtrType:$result);
 
   let assemblyFormat = [{
     `(`
@@ -4666,7 +4667,7 @@ def MemChrOp : CIR_Op<"libc.memchr"> {
 
 class FuncAddrBuiltinOp<string mnemonic> : CIR_Op<mnemonic, []> {
   let arguments = (ins CIR_UInt32:$level);
-  let results = (outs Res<VoidPtr, "">:$result);
+  let results = (outs CIR_VoidPtrType:$result);
   let assemblyFormat = [{
     `(` $level `)` attr-dict
   }];
@@ -4931,7 +4932,7 @@ def AssumeSepStorageOp : CIR_Op<"assume.separate_storage", [SameTypeOperands]> {
     builtin function.
   }];
 
-  let arguments = (ins VoidPtr:$ptr1, VoidPtr:$ptr2);
+  let arguments = (ins CIR_VoidPtrType:$ptr1, CIR_VoidPtrType:$ptr2);
 
   let assemblyFormat = [{
     $ptr1 `,` $ptr2 `:` qualified(type($ptr1)) attr-dict
@@ -5079,7 +5080,7 @@ def FreeExceptionOp : CIR_Op<"free.exception"> {
     ```
   }];
 
-  let arguments = (ins VoidPtr:$ptr);
+  let arguments = (ins CIR_VoidPtrType:$ptr);
   let results = (outs);
 
   let assemblyFormat = [{
@@ -5325,11 +5326,11 @@ def PrefetchOp : CIR_Op<"prefetch"> {
     If $isWrite doesn't specified it means that prefetch is prepared for 'read'.
   }];
 
-  let arguments = (
-    ins VoidPtr:$addr,
-        ConfinedAttr<I32Attr, [IntMinValue<0>,
-          IntMaxValue<3>]>:$locality,
-        UnitAttr:$isWrite);
+  let arguments = (ins
+    CIR_VoidPtrType:$addr,
+    ConfinedAttr<I32Attr, [IntMinValue<0>, IntMaxValue<3>]>:$locality,
+    UnitAttr:$isWrite
+  );
 
   let assemblyFormat = [{
     `(` $addr `:` qualified(type($addr)) `)`
@@ -5349,7 +5350,7 @@ def ClearCacheOp : CIR_Op<"clear_cache", [AllTypesMatch<["begin", "end"]>]> {
     CIR representation for `__builtin___clear_cache`.
   }];
 
-  let arguments = (ins VoidPtr:$begin, VoidPtr:$end);
+  let arguments = (ins CIR_VoidPtrType:$begin, CIR_VoidPtrType:$end);
   let assemblyFormat = [{
     $begin `:` qualified(type($begin)) `,`
     $end `,`

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

@@ -147,4 +147,37 @@ def CIR_AnyIntOrFloatType : AnyTypeOf<[CIR_AnyFloatType, CIR_AnyIntType],
 
 def CIR_AnyComplexType : CIR_TypeBase<"::cir::ComplexType", "complex type">;
 
+//===----------------------------------------------------------------------===//
+// Pointer Type predicates
+//===----------------------------------------------------------------------===//
+
+def CIR_AnyPtrType : CIR_TypeBase<"::cir::PointerType", "pointer type">;
+
+// Pointer to type constraint bases
+class CIR_IsPtrToPred<code type> : CPred<"$_self.isPtrTo<" # type # ">()">;
+
+class CIR_PtrTo<code type, string summary>
+    : CIR_ConfinedType<CIR_AnyPtrType, [CIR_IsPtrToPred<type>],
+        "pointer to " # summary>;
+
+// Pointer to pointer constraint bases
+class CIR_IsPtrToPtrToPred<code type>
+    : CPred<"$_self.isPtrToPtrTo<" # type # ">()">;
+
+class CIR_PtrToPtrTo<code type, string summary>
+    : CIR_ConfinedType<CIR_AnyPtrType, [CIR_IsPtrToPtrToPred<type>],
+        "pointer to pointer to " # summary>;
+
+// Void pointer type constraints
+def CIR_VoidPtrType
+    : CIR_PtrTo<"::cir::VoidType", "void type">,
+      BuildableType<"$_builder.getType<" # cppType # ">("
+        "cir::VoidType::get($_builder.getContext()))">;
+
+def CIR_PtrToVoidPtrType
+    : CIR_PtrToPtrTo<"::cir::VoidType", "void type">,
+      BuildableType<"$_builder.getType<" # cppType # ">("
+        "$_builder.getType<" # cppType # ">("
+        "cir::VoidType::get($_builder.getContext())))">;
+
 #endif // CLANG_CIR_DIALECT_IR_CIRTYPECONSTRAINTS_TD

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

@@ -233,8 +233,30 @@ def CIR_PointerType : CIR_Type<"Pointer", "ptr",
   let skipDefaultBuilders = 1;
 
   let extraClassDeclaration = [{
+    template <typename ...Types>
+    bool isPtrTo() const {
+      return mlir::isa< Types... >(getPointee());
+    }
+
     bool isVoidPtr() const {
-      return mlir::isa<cir::VoidType>(getPointee());
+      return isPtrTo<cir::VoidType>();
+    }
+
+    template <typename ...Types>
+    bool isPtrToPtrTo() const {
+      if (auto ptrType = mlir::dyn_cast<cir::PointerType>(getPointee()))
+        return ptrType.isPtrTo<Types...>();
+      return false;
+    }
+
+    bool isPtrTo(mlir::Type type) const {
+      return getPointee() == type;
+    }
+
+    bool isPtrToPtrTo(mlir::Type type) const {
+      if (auto ptrType = mlir::dyn_cast<cir::PointerType>(getPointee()))
+        return ptrType.isPtrTo(type);
+      return false;
     }
   }];
 }
@@ -483,18 +505,6 @@ def CIR_VoidType : CIR_Type<"Void", "void"> {
 
 // Constraints
 
-// Pointer to void
-def VoidPtr : Type<
-    And<[
-      CPred<"::mlir::isa<::cir::PointerType>($_self)">,
-      CPred<"::mlir::isa<::cir::VoidType>("
-            "::mlir::cast<::cir::PointerType>($_self).getPointee())">,
-    ]>, "void*">,
-    BuildableType<
-      "cir::PointerType::get($_builder.getContext(),"
-      "cir::VoidType::get($_builder.getContext()))"> {
-}
-
 // Pointer to a primitive int, float or double
 def PrimitiveIntOrFPPtr : Type<
     And<[

clang/test/CIR/IR/invalid.cir

@@ -734,7 +734,7 @@ module {
 module {
   // Should not memcpy non-void pointers.
   cir.func @invalid_memcpy_pointer_0(%arg0 : !cir.ptr<!s8i>, %arg1 : !u32i) {
-    // expected-error@+1 {{'cir.libc.memcpy' op operand #0 must be void*, but got '!cir.ptr<!cir.int<s, 8>>'}}
+    // expected-error@+1 {{'cir.libc.memcpy' op operand #0 must be pointer to void type, but got '!cir.ptr<!cir.int<s, 8>>'}}
     cir.libc.memcpy %arg1 bytes from %arg0 to %arg0 : !u32i, !cir.ptr<!s8i> -> !cir.ptr<!s8i>
     cir.return
   }
@@ -747,7 +747,7 @@ module {
 module {
   // Should not memcpy non-void pointers.
   cir.func @invalid_memcpy_pointer_1(%arg0 : !cir.ptr<!cir.void>, %arg1 : !cir.ptr<!s8i>, %arg2 : !u32i) {
-    // expected-error@+1 {{'cir.libc.memcpy' op operand #1 must be void*, but got '!cir.ptr<!cir.int<s, 8>>'}}
+    // expected-error@+1 {{'cir.libc.memcpy' op operand #1 must be pointer to void type, but got '!cir.ptr<!cir.int<s, 8>>'}}
     cir.libc.memcpy %arg2 bytes from %arg1 to %arg0 : !u32i, !cir.ptr<!s8i> -> !cir.ptr<!cir.void>
     cir.return
   }