flang/test/Fir/target-rewrite-complex16.fir

   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>.
   6 func.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>.
  19 func.func private @paramcomplex16(complex<f128>) -> ()
  20
  21 // Test that we rewrite calls to func.functions that return or accept complex<16>.
  22 func.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
  29 func.func private @calleemultipleparamscomplex16(complex<f128>, complex<f128>, complex<f128>) -> ()
  30
  31 func.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>.
  38 func.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.
  44 func.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:         }