[Mlir-commits] [mlir] 79df1a7 - [mlir][llvm] Switch rountrip tests to opaque pointers.
Tobias Gysi
llvmlistbot at llvm.org
Thu Mar 23 00:28:00 PDT 2023
Author: Tobias Gysi
Date: 2023-03-23T08:24:43+01:00
New Revision: 79df1a785d8e45a00906709fc403ba4bd5af4f66
URL: https://github.com/llvm/llvm-project/commit/79df1a785d8e45a00906709fc403ba4bd5af4f66
DIFF: https://github.com/llvm/llvm-project/commit/79df1a785d8e45a00906709fc403ba4bd5af4f66.diff
LOG: [mlir][llvm] Switch rountrip tests to opaque pointers.
The revision switches all remaining LLVM dialect roundtrip
tests to opaque pointers. Selected tests are copied to a
postfixed test file for the time being.
Part of https://discourse.llvm.org/t/rfc-switching-the-llvm-dialect-and-dialect-lowerings-to-opaque-pointers/68179
Reviewed By: zero9178
Differential Revision: https://reviews.llvm.org/D146639
Added:
mlir/test/Dialect/LLVMIR/roundtrip-typed-pointers.mlir
Modified:
mlir/test/Dialect/LLVMIR/roundtrip.mlir
Removed:
################################################################################
diff --git a/mlir/test/Dialect/LLVMIR/roundtrip-typed-pointers.mlir b/mlir/test/Dialect/LLVMIR/roundtrip-typed-pointers.mlir
new file mode 100644
index 000000000000..7cc5a6deee54
--- /dev/null
+++ b/mlir/test/Dialect/LLVMIR/roundtrip-typed-pointers.mlir
@@ -0,0 +1,73 @@
+// RUN: mlir-opt %s | mlir-opt | FileCheck %s
+
+// CHECK-LABEL: func @ops
+// CHECK-SAME: %[[I32:.*]]: i32
+func.func @ops(%arg0: i32) {
+// Memory-related operations.
+//
+// CHECK-NEXT: %[[ALLOCA:.*]] = llvm.alloca %[[I32]] x f64 : (i32) -> !llvm.ptr<f64>
+// CHECK-NEXT: %[[GEP:.*]] = llvm.getelementptr %[[ALLOCA]][%[[I32]], %[[I32]]] : (!llvm.ptr<f64>, i32, i32) -> !llvm.ptr<f64>
+// CHECK-NEXT: %[[VALUE:.*]] = llvm.load %[[GEP]] : !llvm.ptr<f64>
+// CHECK-NEXT: llvm.store %[[VALUE]], %[[ALLOCA]] : !llvm.ptr<f64>
+// CHECK-NEXT: %{{.*}} = llvm.bitcast %[[ALLOCA]] : !llvm.ptr<f64> to !llvm.ptr<i64>
+ %13 = llvm.alloca %arg0 x f64 : (i32) -> !llvm.ptr<f64>
+ %14 = llvm.getelementptr %13[%arg0, %arg0] : (!llvm.ptr<f64>, i32, i32) -> !llvm.ptr<f64>
+ %15 = llvm.load %14 : !llvm.ptr<f64>
+ llvm.store %15, %13 : !llvm.ptr<f64>
+ %16 = llvm.bitcast %13 : !llvm.ptr<f64> to !llvm.ptr<i64>
+ llvm.return
+}
+
+// CHECK-LABEL: @gep
+llvm.func @gep(%ptr: !llvm.ptr<struct<(i32, struct<(i32, f32)>)>>, %idx: i64,
+ %ptr2: !llvm.ptr<struct<(array<10 x f32>)>>) {
+ // CHECK: llvm.getelementptr %{{.*}}[%{{.*}}, 1, 0] : (!llvm.ptr<struct<(i32, struct<(i32, f32)>)>>, i64) -> !llvm.ptr<i32>
+ llvm.getelementptr %ptr[%idx, 1, 0] : (!llvm.ptr<struct<(i32, struct<(i32, f32)>)>>, i64) -> !llvm.ptr<i32>
+ // CHECK: llvm.getelementptr inbounds %{{.*}}[%{{.*}}, 0, %{{.*}}] : (!llvm.ptr<struct<(array<10 x f32>)>>, i64, i64) -> !llvm.ptr<f32>
+ llvm.getelementptr inbounds %ptr2[%idx, 0, %idx] : (!llvm.ptr<struct<(array<10 x f32>)>>, i64, i64) -> !llvm.ptr<f32>
+ llvm.return
+}
+
+// CHECK-LABEL: @alloca
+func.func @alloca(%size : i64) {
+ // CHECK: llvm.alloca %{{.*}} x i32 : (i64) -> !llvm.ptr<i32>
+ llvm.alloca %size x i32 {alignment = 0} : (i64) -> (!llvm.ptr<i32>)
+ // CHECK: llvm.alloca inalloca %{{.*}} x i32 {alignment = 8 : i64} : (i64) -> !llvm.ptr<i32>
+ llvm.alloca inalloca %size x i32 {alignment = 8} : (i64) -> (!llvm.ptr<i32>)
+ llvm.return
+}
+
+// CHECK-LABEL: @null
+func.func @null() {
+ // CHECK: llvm.mlir.null : !llvm.ptr<i8>
+ %0 = llvm.mlir.null : !llvm.ptr<i8>
+ // CHECK: llvm.mlir.null : !llvm.ptr<struct<(ptr<func<void (i32, ptr<func<void ()>>)>>, i64)>>
+ %1 = llvm.mlir.null : !llvm.ptr<struct<(ptr<func<void (i32, ptr<func<void ()>>)>>, i64)>>
+ llvm.return
+}
+
+// CHECK-LABEL: llvm.func @vararg_func
+llvm.func @vararg_func(%arg0: i32, ...) {
+ // CHECK: %{{.*}} = llvm.mlir.constant(1 : i32) : i32
+ // CHECK: %{{.*}} = llvm.mlir.constant(1 : i32) : i32
+ %0 = llvm.mlir.constant(1 : i32) : i32
+ %1 = llvm.mlir.constant(1 : i32) : i32
+ // CHECK: %[[ALLOCA0:.+]] = llvm.alloca %{{.*}} x !llvm.struct<"struct.va_list", (ptr<i8>)> {alignment = 8 : i64} : (i32) -> !llvm.ptr<struct<"struct.va_list", (ptr<i8>)>>
+ // CHECK: %[[CAST0:.+]] = llvm.bitcast %[[ALLOCA0]] : !llvm.ptr<struct<"struct.va_list", (ptr<i8>)>> to !llvm.ptr<i8>
+ %2 = llvm.alloca %1 x !llvm.struct<"struct.va_list", (ptr<i8>)> {alignment = 8 : i64} : (i32) -> !llvm.ptr<struct<"struct.va_list", (ptr<i8>)>>
+ %3 = llvm.bitcast %2 : !llvm.ptr<struct<"struct.va_list", (ptr<i8>)>> to !llvm.ptr<i8>
+ // CHECK: llvm.intr.vastart %[[CAST0]]
+ llvm.intr.vastart %3 : !llvm.ptr<i8>
+ // CHECK: %[[ALLOCA1:.+]] = llvm.alloca %{{.*}} x !llvm.ptr<i8> {alignment = 8 : i64} : (i32) -> !llvm.ptr<ptr<i8>>
+ // CHECK: %[[CAST1:.+]] = llvm.bitcast %[[ALLOCA1]] : !llvm.ptr<ptr<i8>> to !llvm.ptr<i8>
+ %4 = llvm.alloca %0 x !llvm.ptr<i8> {alignment = 8 : i64} : (i32) -> !llvm.ptr<ptr<i8>>
+ %5 = llvm.bitcast %4 : !llvm.ptr<ptr<i8>> to !llvm.ptr<i8>
+ // CHECK: llvm.intr.vacopy %[[CAST0]] to %[[CAST1]]
+ llvm.intr.vacopy %3 to %5 : !llvm.ptr<i8>, !llvm.ptr<i8>
+ // CHECK: llvm.intr.vaend %[[CAST1]]
+ // CHECK: llvm.intr.vaend %[[CAST0]]
+ llvm.intr.vaend %5 : !llvm.ptr<i8>
+ llvm.intr.vaend %3 : !llvm.ptr<i8>
+ // CHECK: llvm.return
+ llvm.return
+}
diff --git a/mlir/test/Dialect/LLVMIR/roundtrip.mlir b/mlir/test/Dialect/LLVMIR/roundtrip.mlir
index c495a36bc067..b430c56fe7aa 100644
--- a/mlir/test/Dialect/LLVMIR/roundtrip.mlir
+++ b/mlir/test/Dialect/LLVMIR/roundtrip.mlir
@@ -1,10 +1,10 @@
// RUN: mlir-opt %s | mlir-opt | FileCheck %s
// CHECK-LABEL: func @ops
-// CHECK-SAME: (%[[I32:.*]]: i32, %[[FLOAT:.*]]: f32, %[[I8PTR1:.*]]: !llvm.ptr<i8>, %[[I8PTR2:.*]]: !llvm.ptr<i8>, %[[BOOL:.*]]: i1, %[[VI8PTR1:.*]]: !llvm.vec<2 x ptr<i8>>)
+// CHECK-SAME: (%[[I32:.*]]: i32, %[[FLOAT:.*]]: f32, %[[PTR1:.*]]: !llvm.ptr, %[[PTR2:.*]]: !llvm.ptr, %[[BOOL:.*]]: i1, %[[VPTR1:.*]]: !llvm.vec<2 x ptr>)
func.func @ops(%arg0: i32, %arg1: f32,
- %arg2: !llvm.ptr<i8>, %arg3: !llvm.ptr<i8>,
- %arg4: i1, %arg5 : !llvm.vec<2x!llvm.ptr<i8>>) {
+ %arg2: !llvm.ptr, %arg3: !llvm.ptr,
+ %arg4: i1, %arg5 : !llvm.vec<2x!llvm.ptr>) {
// Integer arithmetic binary operations.
//
// CHECK: {{.*}} = llvm.add %[[I32]], %[[I32]] : i32
@@ -16,9 +16,9 @@ func.func @ops(%arg0: i32, %arg1: f32,
// CHECK: {{.*}} = llvm.srem %[[I32]], %[[I32]] : i32
// CHECK: %[[SCALAR_PRED0:.+]] = llvm.icmp "ne" %[[I32]], %[[I32]] : i32
// CHECK: {{.*}} = llvm.add %[[SCALAR_PRED0]], %[[SCALAR_PRED0]] : i1
-// CHECK: %[[SCALAR_PRED1:.+]] = llvm.icmp "ne" %[[I8PTR1]], %[[I8PTR1]] : !llvm.ptr<i8>
+// CHECK: %[[SCALAR_PRED1:.+]] = llvm.icmp "ne" %[[PTR1]], %[[PTR1]] : !llvm.ptr
// CHECK: {{.*}} = llvm.add %[[SCALAR_PRED1]], %[[SCALAR_PRED1]] : i1
-// CHECK: %[[VEC_PRED:.+]] = llvm.icmp "ne" %[[VI8PTR1]], %[[VI8PTR1]] : !llvm.vec<2 x ptr<i8>>
+// CHECK: %[[VEC_PRED:.+]] = llvm.icmp "ne" %[[VPTR1]], %[[VPTR1]] : !llvm.vec<2 x ptr>
// CHECK: {{.*}} = llvm.add %[[VEC_PRED]], %[[VEC_PRED]] : vector<2xi1>
%0 = llvm.add %arg0, %arg0 : i32
%1 = llvm.sub %arg0, %arg0 : i32
@@ -29,9 +29,9 @@ func.func @ops(%arg0: i32, %arg1: f32,
%6 = llvm.srem %arg0, %arg0 : i32
%7 = llvm.icmp "ne" %arg0, %arg0 : i32
%typecheck_7 = llvm.add %7, %7 : i1
- %ptrcmp = llvm.icmp "ne" %arg2, %arg2 : !llvm.ptr<i8>
+ %ptrcmp = llvm.icmp "ne" %arg2, %arg2 : !llvm.ptr
%typecheck_ptrcmp = llvm.add %ptrcmp, %ptrcmp : i1
- %vptrcmp = llvm.icmp "ne" %arg5, %arg5 : !llvm.vec<2 x ptr<i8>>
+ %vptrcmp = llvm.icmp "ne" %arg5, %arg5 : !llvm.vec<2 x ptr>
%typecheck_vptrcmp = llvm.add %vptrcmp, %vptrcmp : vector<2 x i1>
// Floating point binary operations.
@@ -49,16 +49,14 @@ func.func @ops(%arg0: i32, %arg1: f32,
// Memory-related operations.
//
-// CHECK-NEXT: %[[ALLOCA:.*]] = llvm.alloca %[[I32]] x f64 : (i32) -> !llvm.ptr<f64>
-// CHECK-NEXT: %[[GEP:.*]] = llvm.getelementptr %[[ALLOCA]][%[[I32]], %[[I32]]] : (!llvm.ptr<f64>, i32, i32) -> !llvm.ptr<f64>
-// CHECK-NEXT: %[[VALUE:.*]] = llvm.load %[[GEP]] : !llvm.ptr<f64>
-// CHECK-NEXT: llvm.store %[[VALUE]], %[[ALLOCA]] : !llvm.ptr<f64>
-// CHECK-NEXT: %{{.*}} = llvm.bitcast %[[ALLOCA]] : !llvm.ptr<f64> to !llvm.ptr<i64>
- %13 = llvm.alloca %arg0 x f64 : (i32) -> !llvm.ptr<f64>
- %14 = llvm.getelementptr %13[%arg0, %arg0] : (!llvm.ptr<f64>, i32, i32) -> !llvm.ptr<f64>
- %15 = llvm.load %14 : !llvm.ptr<f64>
- llvm.store %15, %13 : !llvm.ptr<f64>
- %16 = llvm.bitcast %13 : !llvm.ptr<f64> to !llvm.ptr<i64>
+// CHECK-NEXT: %[[ALLOCA:.*]] = llvm.alloca %[[I32]] x f64 : (i32) -> !llvm.ptr
+// CHECK-NEXT: %[[GEP:.*]] = llvm.getelementptr %[[ALLOCA]][%[[I32]], %[[I32]]] : (!llvm.ptr, i32, i32) -> !llvm.ptr, f64
+// CHECK-NEXT: %[[VALUE:.*]] = llvm.load %[[GEP]] : !llvm.ptr -> f64
+// CHECK-NEXT: llvm.store %[[VALUE]], %[[ALLOCA]] : f64, !llvm.ptr
+ %13 = llvm.alloca %arg0 x f64 : (i32) -> !llvm.ptr
+ %14 = llvm.getelementptr %13[%arg0, %arg0] : (!llvm.ptr, i32, i32) -> !llvm.ptr, f64
+ %15 = llvm.load %14 : !llvm.ptr -> f64
+ llvm.store %15, %13 : f64, !llvm.ptr
// Function call-related operations.
//
@@ -130,10 +128,10 @@ func.func @ops(%arg0: i32, %arg1: f32,
// Integer to pointer and pointer to integer conversions.
//
-// CHECK: %[[PTR:.*]] = llvm.inttoptr %[[I32]] : i32 to !llvm.ptr<i32>
-// CHECK: %{{.*}} = llvm.ptrtoint %[[PTR]] : !llvm.ptr<i32> to i32
- %25 = llvm.inttoptr %arg0 : i32 to !llvm.ptr<i32>
- %26 = llvm.ptrtoint %25 : !llvm.ptr<i32> to i32
+// CHECK: %[[PTR:.*]] = llvm.inttoptr %[[I32]] : i32 to !llvm.ptr
+// CHECK: %{{.*}} = llvm.ptrtoint %[[PTR]] : !llvm.ptr to i32
+ %25 = llvm.inttoptr %arg0 : i32 to !llvm.ptr
+ %26 = llvm.ptrtoint %25 : !llvm.ptr to i32
// Extended and Quad floating point
//
@@ -163,28 +161,27 @@ func.func @ops(%arg0: i32, %arg1: f32,
// CHECK: llvm.intr.round(%[[FLOAT]]) : (f32) -> f32
%34 = llvm.intr.round(%arg1) : (f32) -> f32
-// CHECK: "llvm.intr.memcpy"(%{{.*}}, %{{.*}}, %{{.*}}, %{{.*}}) : (!llvm.ptr<i8>, !llvm.ptr<i8>, i32, i1) -> ()
- "llvm.intr.memcpy"(%arg2, %arg3, %arg0, %arg4) : (!llvm.ptr<i8>, !llvm.ptr<i8>, i32, i1) -> ()
+// CHECK: "llvm.intr.memcpy"(%{{.*}}, %{{.*}}, %{{.*}}, %{{.*}}) : (!llvm.ptr, !llvm.ptr, i32, i1) -> ()
+ "llvm.intr.memcpy"(%arg2, %arg3, %arg0, %arg4) : (!llvm.ptr, !llvm.ptr, i32, i1) -> ()
-// CHECK: "llvm.intr.memcpy"(%{{.*}}, %{{.*}}, %{{.*}}, %{{.*}}) : (!llvm.ptr<i8>, !llvm.ptr<i8>, i32, i1) -> ()
- "llvm.intr.memcpy"(%arg2, %arg3, %arg0, %arg4) : (!llvm.ptr<i8>, !llvm.ptr<i8>, i32, i1) -> ()
+// CHECK: "llvm.intr.memcpy"(%{{.*}}, %{{.*}}, %{{.*}}, %{{.*}}) : (!llvm.ptr, !llvm.ptr, i32, i1) -> ()
+ "llvm.intr.memcpy"(%arg2, %arg3, %arg0, %arg4) : (!llvm.ptr, !llvm.ptr, i32, i1) -> ()
// CHECK: %[[SZ:.*]] = llvm.mlir.constant
%sz = llvm.mlir.constant(10: i64) : i64
-// CHECK: "llvm.intr.memcpy.inline"(%{{.*}}, %{{.*}}, %{{.*}}, %{{.*}}) : (!llvm.ptr<i8>, !llvm.ptr<i8>, i64, i1) -> ()
- "llvm.intr.memcpy.inline"(%arg2, %arg3, %sz, %arg4) : (!llvm.ptr<i8>, !llvm.ptr<i8>, i64, i1) -> ()
+// CHECK: "llvm.intr.memcpy.inline"(%{{.*}}, %{{.*}}, %{{.*}}, %{{.*}}) : (!llvm.ptr, !llvm.ptr, i64, i1) -> ()
+ "llvm.intr.memcpy.inline"(%arg2, %arg3, %sz, %arg4) : (!llvm.ptr, !llvm.ptr, i64, i1) -> ()
// CHECK: llvm.return
llvm.return
}
// CHECK-LABEL: @gep
-llvm.func @gep(%ptr: !llvm.ptr<struct<(i32, struct<(i32, f32)>)>>, %idx: i64,
- %ptr2: !llvm.ptr<struct<(array<10 x f32>)>>) {
- // CHECK: llvm.getelementptr %{{.*}}[%{{.*}}, 1, 0] : (!llvm.ptr<struct<(i32, struct<(i32, f32)>)>>, i64) -> !llvm.ptr<i32>
- llvm.getelementptr %ptr[%idx, 1, 0] : (!llvm.ptr<struct<(i32, struct<(i32, f32)>)>>, i64) -> !llvm.ptr<i32>
- // CHECK: llvm.getelementptr inbounds %{{.*}}[%{{.*}}, 0, %{{.*}}] : (!llvm.ptr<struct<(array<10 x f32>)>>, i64, i64) -> !llvm.ptr<f32>
- llvm.getelementptr inbounds %ptr2[%idx, 0, %idx] : (!llvm.ptr<struct<(array<10 x f32>)>>, i64, i64) -> !llvm.ptr<f32>
+llvm.func @gep(%ptr: !llvm.ptr, %idx: i64, %ptr2: !llvm.ptr) {
+ // CHECK: llvm.getelementptr %{{.*}}[%{{.*}}, 1, 0] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(i32, struct<(i32, f32)>)>
+ llvm.getelementptr %ptr[%idx, 1, 0] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(i32, struct<(i32, f32)>)>
+ // CHECK: llvm.getelementptr inbounds %{{.*}}[%{{.*}}, 0, %{{.*}}] : (!llvm.ptr, i64, i64) -> !llvm.ptr, !llvm.struct<(array<10 x f32>)>
+ llvm.getelementptr inbounds %ptr2[%idx, 0, %idx] : (!llvm.ptr, i64, i64) -> !llvm.ptr, !llvm.struct<(array<10 x f32>)>
llvm.return
}
@@ -248,9 +245,9 @@ llvm.func @foo(%arg0: i32) -> !llvm.struct<(i32, f64, i32)> {
}
// CHECK-LABEL: @casts
-// CHECK-SAME: (%[[I32:.*]]: i32, %[[I64:.*]]: i64, %[[V4I32:.*]]: vector<4xi32>, %[[V4I64:.*]]: vector<4xi64>, %[[I32PTR:.*]]: !llvm.ptr<i32>)
+// CHECK-SAME: (%[[I32:.*]]: i32, %[[I64:.*]]: i64, %[[V4I32:.*]]: vector<4xi32>, %[[V4I64:.*]]: vector<4xi64>, %[[PTR:.*]]: !llvm.ptr)
func.func @casts(%arg0: i32, %arg1: i64, %arg2: vector<4xi32>,
- %arg3: vector<4xi64>, %arg4: !llvm.ptr<i32>) {
+ %arg3: vector<4xi64>, %arg4: !llvm.ptr) {
// CHECK: = llvm.sext %[[I32]] : i32 to i56
%0 = llvm.sext %arg0 : i32 to i56
// CHECK: = llvm.zext %[[I32]] : i32 to i64
@@ -271,21 +268,23 @@ func.func @casts(%arg0: i32, %arg1: i64, %arg2: vector<4xi32>,
%8 = llvm.fptosi %7 : f32 to i32
// CHECK: = llvm.fptoui %[[FLOAT]] : f32 to i32
%9 = llvm.fptoui %7 : f32 to i32
-// CHECK: = llvm.addrspacecast %[[I32PTR]] : !llvm.ptr<i32> to !llvm.ptr<i32, 2>
- %10 = llvm.addrspacecast %arg4 : !llvm.ptr<i32> to !llvm.ptr<i32, 2>
+// CHECK: = llvm.addrspacecast %[[PTR]] : !llvm.ptr to !llvm.ptr<2>
+ %10 = llvm.addrspacecast %arg4 : !llvm.ptr to !llvm.ptr<2>
+// CHECK: = llvm.bitcast %[[I64]] : i64 to f64
+ %11 = llvm.bitcast %arg1 : i64 to f64
llvm.return
}
// CHECK-LABEL: @vect
-func.func @vect(%arg0: vector<4xf32>, %arg1: i32, %arg2: f32, %arg3: !llvm.vec<2 x ptr<i32>>) {
+func.func @vect(%arg0: vector<4xf32>, %arg1: i32, %arg2: f32, %arg3: !llvm.vec<2 x ptr>) {
// CHECK: = llvm.extractelement {{.*}} : vector<4xf32>
%0 = llvm.extractelement %arg0[%arg1 : i32] : vector<4xf32>
// CHECK: = llvm.insertelement {{.*}} : vector<4xf32>
%1 = llvm.insertelement %arg2, %arg0[%arg1 : i32] : vector<4xf32>
// CHECK: = llvm.shufflevector {{.*}} [0, 0, 0, 0, 7] : vector<4xf32>
%2 = llvm.shufflevector %arg0, %arg0 [0, 0, 0, 0, 7] : vector<4xf32>
-// CHECK: = llvm.shufflevector %{{.+}}, %{{.+}} [1, 0] : !llvm.vec<2 x ptr<i32>>
- %3 = llvm.shufflevector %arg3, %arg3 [1, 0] : !llvm.vec<2 x ptr<i32>>
+// CHECK: = llvm.shufflevector %{{.+}}, %{{.+}} [1, 0] : !llvm.vec<2 x ptr>
+ %3 = llvm.shufflevector %arg3, %arg3 [1, 0] : !llvm.vec<2 x ptr>
// CHECK: = llvm.mlir.constant(dense<1.000000e+00> : vector<4xf32>) : vector<4xf32>
%4 = llvm.mlir.constant(dense<1.0> : vector<4xf32>) : vector<4xf32>
return
@@ -323,19 +322,17 @@ func.func @mixed_vect(%arg0: vector<8xf32>, %arg1: vector<4xf32>, %arg2: vector<
// CHECK-LABEL: @alloca
func.func @alloca(%size : i64) {
- // CHECK: llvm.alloca %{{.*}} x i32 : (i64) -> !llvm.ptr<i32>
- llvm.alloca %size x i32 {alignment = 0} : (i64) -> (!llvm.ptr<i32>)
- // CHECK: llvm.alloca inalloca %{{.*}} x i32 {alignment = 8 : i64} : (i64) -> !llvm.ptr<i32>
- llvm.alloca inalloca %size x i32 {alignment = 8} : (i64) -> (!llvm.ptr<i32>)
+ // CHECK: llvm.alloca %{{.*}} x i32 : (i64) -> !llvm.ptr
+ llvm.alloca %size x i32 {alignment = 0} : (i64) -> (!llvm.ptr)
+ // CHECK: llvm.alloca inalloca %{{.*}} x i32 {alignment = 8 : i64} : (i64) -> !llvm.ptr
+ llvm.alloca inalloca %size x i32 {alignment = 8} : (i64) -> (!llvm.ptr)
llvm.return
}
// CHECK-LABEL: @null
func.func @null() {
- // CHECK: llvm.mlir.null : !llvm.ptr<i8>
- %0 = llvm.mlir.null : !llvm.ptr<i8>
- // CHECK: llvm.mlir.null : !llvm.ptr<struct<(ptr<func<void (i32, ptr<func<void ()>>)>>, i64)>>
- %1 = llvm.mlir.null : !llvm.ptr<struct<(ptr<func<void (i32, ptr<func<void ()>>)>>, i64)>>
+ // CHECK: llvm.mlir.null : !llvm.ptr
+ %0 = llvm.mlir.null : !llvm.ptr
llvm.return
}
@@ -375,61 +372,57 @@ func.func @cmpxchg(%ptr : !llvm.ptr, %cmp : i32, %new : i32) {
llvm.return
}
-llvm.mlir.global external constant @_ZTIi() : !llvm.ptr<i8>
-llvm.func @bar(!llvm.ptr<i8>, !llvm.ptr<i8>, !llvm.ptr<i8>)
+llvm.mlir.global external constant @_ZTIi() : !llvm.ptr
+llvm.func @bar(!llvm.ptr, !llvm.ptr, !llvm.ptr)
llvm.func @__gxx_personality_v0(...) -> i32
// CHECK-LABEL: @invokeLandingpad
llvm.func @invokeLandingpad() -> i32 attributes { personality = @__gxx_personality_v0 } {
-// CHECK: %[[a0:.*]] = llvm.mlir.constant(0 : i32) : i32
+// CHECK: %[[V0:.*]] = llvm.mlir.constant(0 : i32) : i32
// CHECK: %{{.*}} = llvm.mlir.constant(3 : i32) : i32
-// CHECK: %[[a2:.*]] = llvm.mlir.constant("\01") : !llvm.array<1 x i8>
-// CHECK: %[[a3:.*]] = llvm.mlir.null : !llvm.ptr<ptr<i8>>
-// CHECK: %[[a4:.*]] = llvm.mlir.null : !llvm.ptr<i8>
-// CHECK: %[[a5:.*]] = llvm.mlir.addressof @_ZTIi : !llvm.ptr<ptr<i8>>
-// CHECK: %[[a6:.*]] = llvm.bitcast %[[a5]] : !llvm.ptr<ptr<i8>> to !llvm.ptr<i8>
-// CHECK: %[[a7:.*]] = llvm.mlir.constant(1 : i32) : i32
-// CHECK: %[[a8:.*]] = llvm.alloca %[[a7]] x i8 : (i32) -> !llvm.ptr<i8>
-// CHECK: %{{.*}} = llvm.invoke @foo(%[[a7]]) to ^[[BB2:.*]] unwind ^[[BB1:.*]] : (i32) -> !llvm.struct<(i32, f64, i32)>
+// CHECK: %[[V1:.*]] = llvm.mlir.constant("\01") : !llvm.array<1 x i8>
+// CHECK: %[[V2:.*]] = llvm.mlir.null : !llvm.ptr
+// CHECK: %[[V3:.*]] = llvm.mlir.addressof @_ZTIi : !llvm.ptr
+// CHECK: %[[V4:.*]] = llvm.mlir.constant(1 : i32) : i32
+// CHECK: %[[V5:.*]] = llvm.alloca %[[V4]] x i8 : (i32) -> !llvm.ptr
+// CHECK: %{{.*}} = llvm.invoke @foo(%[[V4]]) to ^[[BB2:.*]] unwind ^[[BB1:.*]] : (i32) -> !llvm.struct<(i32, f64, i32)>
%0 = llvm.mlir.constant(0 : i32) : i32
%1 = llvm.mlir.constant(3 : i32) : i32
%2 = llvm.mlir.constant("\01") : !llvm.array<1 x i8>
- %3 = llvm.mlir.null : !llvm.ptr<ptr<i8>>
- %4 = llvm.mlir.null : !llvm.ptr<i8>
- %5 = llvm.mlir.addressof @_ZTIi : !llvm.ptr<ptr<i8>>
- %6 = llvm.bitcast %5 : !llvm.ptr<ptr<i8>> to !llvm.ptr<i8>
- %7 = llvm.mlir.constant(1 : i32) : i32
- %8 = llvm.alloca %7 x i8 : (i32) -> !llvm.ptr<i8>
- %9 = llvm.invoke @foo(%7) to ^bb2 unwind ^bb1 : (i32) -> !llvm.struct<(i32, f64, i32)>
+ %3 = llvm.mlir.null : !llvm.ptr
+ %4 = llvm.mlir.addressof @_ZTIi : !llvm.ptr
+ %5 = llvm.mlir.constant(1 : i32) : i32
+ %6 = llvm.alloca %5 x i8 : (i32) -> !llvm.ptr
+ %7 = llvm.invoke @foo(%5) to ^bb2 unwind ^bb1 : (i32) -> !llvm.struct<(i32, f64, i32)>
// CHECK: ^[[BB1]]:
-// CHECK: %[[lp:.*]] = llvm.landingpad cleanup (catch %[[a3]] : !llvm.ptr<ptr<i8>>) (catch %[[a6]] : !llvm.ptr<i8>) (filter %[[a2]] : !llvm.array<1 x i8>) : !llvm.struct<(ptr<i8>, i32)>
-// CHECK: %{{.*}} = llvm.intr.eh.typeid.for %6 : (!llvm.ptr<i8>) -> i32
-// CHECK: llvm.resume %[[lp]] : !llvm.struct<(ptr<i8>, i32)>
+// CHECK: %[[lp:.*]] = llvm.landingpad cleanup (catch %[[V2]] : !llvm.ptr) (catch %[[V3]] : !llvm.ptr) (filter %[[V1]] : !llvm.array<1 x i8>) : !llvm.struct<(ptr, i32)>
+// CHECK: %{{.*}} = llvm.intr.eh.typeid.for %[[V3]] : (!llvm.ptr) -> i32
+// CHECK: llvm.resume %[[lp]] : !llvm.struct<(ptr, i32)>
^bb1:
- %10 = llvm.landingpad cleanup (catch %3 : !llvm.ptr<ptr<i8>>) (catch %6 : !llvm.ptr<i8>) (filter %2 : !llvm.array<1 x i8>) : !llvm.struct<(ptr<i8>, i32)>
- %11 = llvm.intr.eh.typeid.for %6 : (!llvm.ptr<i8>) -> i32
- llvm.resume %10 : !llvm.struct<(ptr<i8>, i32)>
+ %10 = llvm.landingpad cleanup (catch %3 : !llvm.ptr) (catch %4 : !llvm.ptr) (filter %2 : !llvm.array<1 x i8>) : !llvm.struct<(ptr, i32)>
+ %11 = llvm.intr.eh.typeid.for %4 : (!llvm.ptr) -> i32
+ llvm.resume %10 : !llvm.struct<(ptr, i32)>
// CHECK: ^[[BB2]]:
-// CHECK: llvm.return %[[a7]] : i32
+// CHECK: llvm.return %[[V4]] : i32
^bb2:
- llvm.return %7 : i32
+ llvm.return %5 : i32
// CHECK: ^[[BB3:.*]]:
-// CHECK: llvm.invoke @bar(%[[a8]], %[[a6]], %[[a4]]) to ^[[BB2]] unwind ^[[BB1]] : (!llvm.ptr<i8>, !llvm.ptr<i8>, !llvm.ptr<i8>) -> ()
+// CHECK: llvm.invoke @bar(%[[V5]], %[[V3]], %[[V2]]) to ^[[BB2]] unwind ^[[BB1]] : (!llvm.ptr, !llvm.ptr, !llvm.ptr) -> ()
^bb3:
- llvm.invoke @bar(%8, %6, %4) to ^bb2 unwind ^bb1 : (!llvm.ptr<i8>, !llvm.ptr<i8>, !llvm.ptr<i8>) -> ()
+ llvm.invoke @bar(%6, %4, %3) to ^bb2 unwind ^bb1 : (!llvm.ptr, !llvm.ptr, !llvm.ptr) -> ()
// CHECK: ^[[BB4:.*]]:
// CHECK: %[[FUNC:.*]] = llvm.mlir.addressof @foo : !llvm.ptr
// CHECK: %{{.*}} = llvm.invoke %[[FUNC]]{{.*}}: !llvm.ptr,
^bb4:
%12 = llvm.mlir.addressof @foo : !llvm.ptr
- %13 = llvm.invoke %12(%7) to ^bb2 unwind ^bb1 : !llvm.ptr, (i32) -> !llvm.struct<(i32, f64, i32)>
+ %13 = llvm.invoke %12(%5) to ^bb2 unwind ^bb1 : !llvm.ptr, (i32) -> !llvm.struct<(i32, f64, i32)>
// CHECK: ^[[BB5:.*]]:
-// CHECK: llvm.return %[[a0]] : i32
+// CHECK: llvm.return %[[V0]] : i32
^bb5:
llvm.return %0 : i32
}
@@ -528,32 +521,6 @@ func.func @fastmathFlags(%arg0: f32, %arg1: f32, %arg2: i32, %arg3: vector<2 x f
return
}
-// CHECK-LABEL: llvm.func @vararg_func
-llvm.func @vararg_func(%arg0: i32, ...) {
- // CHECK: %{{.*}} = llvm.mlir.constant(1 : i32) : i32
- // CHECK: %{{.*}} = llvm.mlir.constant(1 : i32) : i32
- %0 = llvm.mlir.constant(1 : i32) : i32
- %1 = llvm.mlir.constant(1 : i32) : i32
- // CHECK: %[[ALLOCA0:.+]] = llvm.alloca %{{.*}} x !llvm.struct<"struct.va_list", (ptr<i8>)> {alignment = 8 : i64} : (i32) -> !llvm.ptr<struct<"struct.va_list", (ptr<i8>)>>
- // CHECK: %[[CAST0:.+]] = llvm.bitcast %[[ALLOCA0]] : !llvm.ptr<struct<"struct.va_list", (ptr<i8>)>> to !llvm.ptr<i8>
- %2 = llvm.alloca %1 x !llvm.struct<"struct.va_list", (ptr<i8>)> {alignment = 8 : i64} : (i32) -> !llvm.ptr<struct<"struct.va_list", (ptr<i8>)>>
- %3 = llvm.bitcast %2 : !llvm.ptr<struct<"struct.va_list", (ptr<i8>)>> to !llvm.ptr<i8>
- // CHECK: llvm.intr.vastart %[[CAST0]]
- llvm.intr.vastart %3 : !llvm.ptr<i8>
- // CHECK: %[[ALLOCA1:.+]] = llvm.alloca %{{.*}} x !llvm.ptr<i8> {alignment = 8 : i64} : (i32) -> !llvm.ptr<ptr<i8>>
- // CHECK: %[[CAST1:.+]] = llvm.bitcast %[[ALLOCA1]] : !llvm.ptr<ptr<i8>> to !llvm.ptr<i8>
- %4 = llvm.alloca %0 x !llvm.ptr<i8> {alignment = 8 : i64} : (i32) -> !llvm.ptr<ptr<i8>>
- %5 = llvm.bitcast %4 : !llvm.ptr<ptr<i8>> to !llvm.ptr<i8>
- // CHECK: llvm.intr.vacopy %[[CAST0]] to %[[CAST1]]
- llvm.intr.vacopy %3 to %5 : !llvm.ptr<i8>, !llvm.ptr<i8>
- // CHECK: llvm.intr.vaend %[[CAST1]]
- // CHECK: llvm.intr.vaend %[[CAST0]]
- llvm.intr.vaend %5 : !llvm.ptr<i8>
- llvm.intr.vaend %3 : !llvm.ptr<i8>
- // CHECK: llvm.return
- llvm.return
-}
-
// CHECK-LABEL: @lifetime
// CHECK-SAME: %[[P:.*]]: !llvm.ptr
llvm.func @lifetime(%p: !llvm.ptr) {
@@ -564,8 +531,8 @@ llvm.func @lifetime(%p: !llvm.ptr) {
llvm.return
}
-// CHECK-LABEL: @vararg_func_opaque_pointers
-llvm.func @vararg_func_opaque_pointers(%arg0: i32, ...) {
+// CHECK-LABEL: @vararg_func
+llvm.func @vararg_func(%arg0: i32, ...) {
// CHECK: %[[C:.*]] = llvm.mlir.constant(1 : i32)
// CHECK: %[[LIST:.*]] = llvm.alloca
// CHECK: llvm.intr.vastart %[[LIST]] : !llvm.ptr{{$}}
@@ -585,17 +552,17 @@ llvm.func @vararg_func_opaque_pointers(%arg0: i32, ...) {
llvm.return
}
-// CHECK-LABEL: @eh_typeid_opaque_pointers
+// CHECK-LABEL: @eh_typeid
// CHECK-SAME: %[[ARG0:.*]]: !llvm.ptr
-llvm.func @eh_typeid_opaque_pointers(%arg0: !llvm.ptr) -> i32 {
+llvm.func @eh_typeid(%arg0: !llvm.ptr) -> i32 {
// CHECK: llvm.intr.eh.typeid.for %[[ARG0]] : (!llvm.ptr) -> i32
%0 = llvm.intr.eh.typeid.for %arg0 : (!llvm.ptr) -> i32
llvm.return %0 : i32
}
-// CHECK-LABEL: @stackrestore_opaque_pointers
+// CHECK-LABEL: @stackrestore
// CHECK-SAME: %[[ARG0:.*]]: !llvm.ptr
-llvm.func @stackrestore_opaque_pointers(%arg0: !llvm.ptr) {
+llvm.func @stackrestore(%arg0: !llvm.ptr) {
// CHECK: llvm.intr.stackrestore %[[ARG0]] : !llvm.ptr
llvm.intr.stackrestore %arg0 : !llvm.ptr
llvm.return
More information about the Mlir-commits
mailing list