xref: /llvm-project/flang/test/Fir/target-rewrite-complex16.fir (revision 20b442a25d86c35556cfc1bba4356f8ee75987bd) 
1// RUN: fir-opt --target-rewrite="target=x86_64-unknown-linux-gnu" %s | FileCheck %s
2// RUN: fir-opt --target-rewrite="target=loongarch64-unknown-linux-gnu" %s | FileCheck %s
3
4// Test that we rewrite the signature and body of a func.function that returns a
5// complex<16>.
6func.func @returncomplex16() -> complex<f128> {
7  %1 = fir.undefined complex<f128>
8  %2 = arith.constant 2.0 : f128
9  %3 = fir.convert %2 : (f128) -> f128
10  %c0 = arith.constant 0 : i32
11  %4 = fir.insert_value %1, %3, [0 : i32] : (complex<f128>, f128) -> complex<f128>
12  %c1 = arith.constant 1 : i32
13  %5 = arith.constant -42.0 : f128
14  %6 = fir.insert_value %4, %5, [1 : i32] : (complex<f128>, f128) -> complex<f128>
15  return %6 : complex<f128>
16}
17
18// Test that we rewrite the signature of a func.function that accepts a complex<16>.
19func.func private @paramcomplex16(complex<f128>) -> ()
20
21// Test that we rewrite calls to func.functions that return or accept complex<16>.
22func.func @callcomplex16() {
23  %1 = fir.call @returncomplex16() : () -> complex<f128>
24  fir.call @paramcomplex16(%1) : (complex<f128>) -> ()
25  return
26}
27
28// Test multiple complex<16> parameters and arguments
29func.func private @calleemultipleparamscomplex16(complex<f128>, complex<f128>, complex<f128>) -> ()
30
31func.func @multipleparamscomplex16(%z1 : complex<f128>, %z2 : complex<f128>, %z3 : complex<f128>) {
32  fir.call @calleemultipleparamscomplex16(%z1, %z2, %z3) : (complex<f128>, complex<f128>, complex<f128>) -> ()
33  return
34}
35
36// Test that we rewrite the signature of and calls to a func.function that accepts
37// and returns MLIR complex<f128>.
38func.func private @mlircomplexf128(%z1: complex<f128>, %z2: complex<f128>) -> complex<f128> {
39  %0 = fir.call @mlircomplexf128(%z1, %z2) : (complex<f128>, complex<f128>) -> complex<f128>
40  return %0 : complex<f128>
41}
42
43// Test that we rewrite the fir.address_of operator.
44func.func @addrof() {
45  %r = fir.address_of(@returncomplex16) : () -> complex<f128>
46  %p = fir.address_of(@paramcomplex16) : (complex<f128>) -> ()
47  return
48}
49
50// CHECK-LABEL:   func.func @returncomplex16(
51// CHECK-SAME:      %[[VAL_0:.*]]: !fir.ref<tuple<f128, f128>> {llvm.align = 16 : i32, llvm.sret = tuple<f128, f128>}) {
52// CHECK:           %[[VAL_1:.*]] = fir.undefined complex<f128>
53// CHECK:           %[[VAL_2:.*]] = arith.constant 2.000000e+00 : f128
54// CHECK:           %[[VAL_3:.*]] = fir.convert %[[VAL_2]] : (f128) -> f128
55// CHECK:           %[[VAL_4:.*]] = arith.constant 0 : i32
56// CHECK:           %[[VAL_5:.*]] = fir.insert_value %[[VAL_1]], %[[VAL_3]], [0 : i32] : (complex<f128>, f128) -> complex<f128>
57// CHECK:           %[[VAL_6:.*]] = arith.constant 1 : i32
58// CHECK:           %[[VAL_7:.*]] = arith.constant -4.200000e+01 : f128
59// CHECK:           %[[VAL_8:.*]] = fir.insert_value %[[VAL_5]], %[[VAL_7]], [1 : i32] : (complex<f128>, f128) -> complex<f128>
60// CHECK:           %[[VAL_9:.*]] = fir.convert %[[VAL_0]] : (!fir.ref<tuple<f128, f128>>) -> !fir.ref<complex<f128>>
61// CHECK:           fir.store %[[VAL_8]] to %[[VAL_9]] : !fir.ref<complex<f128>>
62// CHECK:           return
63// CHECK:         }
64// CHECK:         func.func private @paramcomplex16(!fir.ref<tuple<f128, f128>> {llvm.align = 16 : i32, llvm.byval = tuple<f128, f128>})
65
66// CHECK-LABEL:   func.func @callcomplex16() {
67// CHECK:           %[[VAL_0:.*]] = llvm.intr.stacksave : !llvm.ptr
68// CHECK:           %[[VAL_1:.*]] = fir.alloca tuple<f128, f128>
69// CHECK:           fir.call @returncomplex16(%[[VAL_1]]) : (!fir.ref<tuple<f128, f128>>) -> ()
70// CHECK:           %[[VAL_2:.*]] = fir.convert %[[VAL_1]] : (!fir.ref<tuple<f128, f128>>) -> !fir.ref<complex<f128>>
71// CHECK:           %[[VAL_3:.*]] = fir.load %[[VAL_2]] : !fir.ref<complex<f128>>
72// CHECK:           llvm.intr.stackrestore %[[VAL_0]] : !llvm.ptr
73// CHECK:           %[[VAL_4:.*]] = llvm.intr.stacksave : !llvm.ptr
74// CHECK:           %[[VAL_5:.*]] = fir.alloca complex<f128>
75// CHECK:           fir.store %[[VAL_3]] to %[[VAL_5]] : !fir.ref<complex<f128>>
76// CHECK:           %[[VAL_6:.*]] = fir.convert %[[VAL_5]] : (!fir.ref<complex<f128>>) -> !fir.ref<tuple<f128, f128>>
77// CHECK:           fir.call @paramcomplex16(%[[VAL_6]]) : (!fir.ref<tuple<f128, f128>>) -> ()
78// CHECK:           llvm.intr.stackrestore %[[VAL_4]] : !llvm.ptr
79// CHECK:           return
80// CHECK:         }
81// CHECK:         func.func private @calleemultipleparamscomplex16(!fir.ref<tuple<f128, f128>> {llvm.align = 16 : i32, llvm.byval = tuple<f128, f128>}, !fir.ref<tuple<f128, f128>> {llvm.align = 16 : i32, llvm.byval = tuple<f128, f128>}, !fir.ref<tuple<f128, f128>> {llvm.align = 16 : i32, llvm.byval = tuple<f128, f128>})
82
83// CHECK-LABEL:   func.func @multipleparamscomplex16(
84// CHECK-SAME:      %[[VAL_0:.*]]: !fir.ref<tuple<f128, f128>> {llvm.align = 16 : i32, llvm.byval = tuple<f128, f128>}, %[[VAL_1:.*]]: !fir.ref<tuple<f128, f128>> {llvm.align = 16 : i32, llvm.byval = tuple<f128, f128>}, %[[VAL_2:.*]]: !fir.ref<tuple<f128, f128>> {llvm.align = 16 : i32, llvm.byval = tuple<f128, f128>}) {
85// CHECK:           %[[VAL_3:.*]] = fir.convert %[[VAL_2]] : (!fir.ref<tuple<f128, f128>>) -> !fir.ref<complex<f128>>
86// CHECK:           %[[VAL_4:.*]] = fir.load %[[VAL_3]] : !fir.ref<complex<f128>>
87// CHECK:           %[[VAL_5:.*]] = fir.convert %[[VAL_1]] : (!fir.ref<tuple<f128, f128>>) -> !fir.ref<complex<f128>>
88// CHECK:           %[[VAL_6:.*]] = fir.load %[[VAL_5]] : !fir.ref<complex<f128>>
89// CHECK:           %[[VAL_7:.*]] = fir.convert %[[VAL_0]] : (!fir.ref<tuple<f128, f128>>) -> !fir.ref<complex<f128>>
90// CHECK:           %[[VAL_8:.*]] = fir.load %[[VAL_7]] : !fir.ref<complex<f128>>
91// CHECK:           %[[VAL_9:.*]] = llvm.intr.stacksave : !llvm.ptr
92// CHECK:           %[[VAL_10:.*]] = fir.alloca complex<f128>
93// CHECK:           fir.store %[[VAL_8]] to %[[VAL_10]] : !fir.ref<complex<f128>>
94// CHECK:           %[[VAL_11:.*]] = fir.convert %[[VAL_10]] : (!fir.ref<complex<f128>>) -> !fir.ref<tuple<f128, f128>>
95// CHECK:           %[[VAL_12:.*]] = fir.alloca complex<f128>
96// CHECK:           fir.store %[[VAL_6]] to %[[VAL_12]] : !fir.ref<complex<f128>>
97// CHECK:           %[[VAL_13:.*]] = fir.convert %[[VAL_12]] : (!fir.ref<complex<f128>>) -> !fir.ref<tuple<f128, f128>>
98// CHECK:           %[[VAL_14:.*]] = fir.alloca complex<f128>
99// CHECK:           fir.store %[[VAL_4]] to %[[VAL_14]] : !fir.ref<complex<f128>>
100// CHECK:           %[[VAL_15:.*]] = fir.convert %[[VAL_14]] : (!fir.ref<complex<f128>>) -> !fir.ref<tuple<f128, f128>>
101// CHECK:           fir.call @calleemultipleparamscomplex16(%[[VAL_11]], %[[VAL_13]], %[[VAL_15]]) : (!fir.ref<tuple<f128, f128>>, !fir.ref<tuple<f128, f128>>, !fir.ref<tuple<f128, f128>>) -> ()
102// CHECK:           llvm.intr.stackrestore %[[VAL_9]] : !llvm.ptr
103// CHECK:           return
104// CHECK:         }
105
106// CHECK-LABEL:   func.func private @mlircomplexf128(
107// CHECK-SAME:      %[[VAL_0:.*]]: !fir.ref<tuple<f128, f128>> {llvm.align = 16 : i32, llvm.sret = tuple<f128, f128>}, %[[VAL_1:.*]]: !fir.ref<tuple<f128, f128>> {llvm.align = 16 : i32, llvm.byval = tuple<f128, f128>}, %[[VAL_2:.*]]: !fir.ref<tuple<f128, f128>> {llvm.align = 16 : i32, llvm.byval = tuple<f128, f128>}) {
108// CHECK:           %[[VAL_3:.*]] = fir.convert %[[VAL_2]] : (!fir.ref<tuple<f128, f128>>) -> !fir.ref<complex<f128>>
109// CHECK:           %[[VAL_4:.*]] = fir.load %[[VAL_3]] : !fir.ref<complex<f128>>
110// CHECK:           %[[VAL_5:.*]] = fir.convert %[[VAL_1]] : (!fir.ref<tuple<f128, f128>>) -> !fir.ref<complex<f128>>
111// CHECK:           %[[VAL_6:.*]] = fir.load %[[VAL_5]] : !fir.ref<complex<f128>>
112// CHECK:           %[[VAL_7:.*]] = llvm.intr.stacksave : !llvm.ptr
113// CHECK:           %[[VAL_8:.*]] = fir.alloca tuple<f128, f128>
114// CHECK:           %[[VAL_9:.*]] = fir.alloca complex<f128>
115// CHECK:           fir.store %[[VAL_6]] to %[[VAL_9]] : !fir.ref<complex<f128>>
116// CHECK:           %[[VAL_10:.*]] = fir.convert %[[VAL_9]] : (!fir.ref<complex<f128>>) -> !fir.ref<tuple<f128, f128>>
117// CHECK:           %[[VAL_11:.*]] = fir.alloca complex<f128>
118// CHECK:           fir.store %[[VAL_4]] to %[[VAL_11]] : !fir.ref<complex<f128>>
119// CHECK:           %[[VAL_12:.*]] = fir.convert %[[VAL_11]] : (!fir.ref<complex<f128>>) -> !fir.ref<tuple<f128, f128>>
120// CHECK:           fir.call @mlircomplexf128(%[[VAL_8]], %[[VAL_10]], %[[VAL_12]]) : (!fir.ref<tuple<f128, f128>>, !fir.ref<tuple<f128, f128>>, !fir.ref<tuple<f128, f128>>) -> ()
121// CHECK:           %[[VAL_13:.*]] = fir.convert %[[VAL_8]] : (!fir.ref<tuple<f128, f128>>) -> !fir.ref<complex<f128>>
122// CHECK:           %[[VAL_14:.*]] = fir.load %[[VAL_13]] : !fir.ref<complex<f128>>
123// CHECK:           llvm.intr.stackrestore %[[VAL_7]] : !llvm.ptr
124// CHECK:           %[[VAL_15:.*]] = fir.convert %[[VAL_0]] : (!fir.ref<tuple<f128, f128>>) -> !fir.ref<complex<f128>>
125// CHECK:           fir.store %[[VAL_14]] to %[[VAL_15]] : !fir.ref<complex<f128>>
126// CHECK:           return
127// CHECK:         }
128
129// CHECK-LABEL:   func.func @addrof() {
130// CHECK:           %[[VAL_0:.*]] = fir.address_of(@returncomplex16) : (!fir.ref<tuple<f128, f128>>) -> ()
131// CHECK:           %[[VAL_1:.*]] = fir.address_of(@paramcomplex16) : (!fir.ref<tuple<f128, f128>>) -> ()
132// CHECK:           return
133// CHECK:         }
134