Debian Codegraph @

flang/test/Fir/struct-passing-x86-64-several-fields-inreg.fir

raw
1 // Test X86-64 passing ABI of struct in registers for the cases where the
2 // struct has more than one field.
3 // RUN: fir-opt -target-rewrite="target=x86_64-unknown-linux-gnu" %s -o - | FileCheck %s
4
5
6 module attributes {fir.defaultkind = "a1c4d8i4l4r4", fir.kindmap = "", llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-i128:128-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu"} {
7
8 func.func @test_call_i8_a16(%0 : !fir.ref<!fir.type<ti8_a16{a:!fir.array<16xi8>}>>) {
9 %1 = fir.load %0 : !fir.ref<!fir.type<ti8_a16{a:!fir.array<16xi8>}>>
10 fir.call @test_func_i8_a16(%1) : (!fir.type<ti8_a16{a:!fir.array<16xi8>}>) -> ()
11 return
12 }
13 // CHECK-LABEL: func.func @test_call_i8_a16(
14 // CHECK-SAME: %[[VAL_0:.*]]: !fir.ref<!fir.type<ti8_a16{a:!fir.array<16xi8>}>>) {
15 // CHECK: %[[VAL_1:.*]] = fir.load %[[VAL_0]] : !fir.ref<!fir.type<ti8_a16{a:!fir.array<16xi8>}>>
16 // CHECK: %[[VAL_2:.*]] = llvm.intr.stacksave : !llvm.ptr
17 // CHECK: %[[VAL_3:.*]] = fir.alloca tuple<i64, i64>
18 // CHECK: %[[VAL_4:.*]] = fir.convert %[[VAL_3]] : (!fir.ref<tuple<i64, i64>>) -> !fir.ref<!fir.type<ti8_a16{a:!fir.array<16xi8>}>>
19 // CHECK: fir.store %[[VAL_1]] to %[[VAL_4]] : !fir.ref<!fir.type<ti8_a16{a:!fir.array<16xi8>}>>
20 // CHECK: %[[VAL_5:.*]] = fir.load %[[VAL_3]] : !fir.ref<tuple<i64, i64>>
21 // CHECK: %[[VAL_6:.*]] = fir.extract_value %[[VAL_5]], [0 : i32] : (tuple<i64, i64>) -> i64
22 // CHECK: %[[VAL_7:.*]] = fir.extract_value %[[VAL_5]], [1 : i32] : (tuple<i64, i64>) -> i64
23 // CHECK: fir.call @test_func_i8_a16(%[[VAL_6]], %[[VAL_7]]) : (i64, i64) -> ()
24 // CHECK: llvm.intr.stackrestore %[[VAL_2]] : !llvm.ptr
25 // CHECK: return
26
27 func.func private @test_func_i8_a16(%0 : !fir.type<ti8_a16{a:!fir.array<16xi8>}>) -> () {
28 return
29 }
30 // CHECK-LABEL: func.func private @test_func_i8_a16(
31 // CHECK-SAME: %[[VAL_0:.*]]: i64,
32 // CHECK-SAME: %[[VAL_1:.*]]: i64) {
33 // CHECK: %[[VAL_2:.*]] = fir.undefined tuple<i64, i64>
34 // CHECK: %[[VAL_3:.*]] = fir.insert_value %[[VAL_2]], %[[VAL_0]], [0 : i32] : (tuple<i64, i64>, i64) -> tuple<i64, i64>
35 // CHECK: %[[VAL_4:.*]] = fir.insert_value %[[VAL_3]], %[[VAL_1]], [1 : i32] : (tuple<i64, i64>, i64) -> tuple<i64, i64>
36 // CHECK: %[[VAL_5:.*]] = fir.alloca tuple<i64, i64>
37 // CHECK: fir.store %[[VAL_4]] to %[[VAL_5]] : !fir.ref<tuple<i64, i64>>
38 // CHECK: %[[VAL_6:.*]] = fir.convert %[[VAL_5]] : (!fir.ref<tuple<i64, i64>>) -> !fir.ref<!fir.type<ti8_a16{a:!fir.array<16xi8>}>>
39 // CHECK: %[[VAL_7:.*]] = fir.load %[[VAL_6]] : !fir.ref<!fir.type<ti8_a16{a:!fir.array<16xi8>}>>
40 // CHECK: return
41
42
43 // For the cases below, the argument marshalling logic is the same as above,
44 // so only the chosen signature is tested at the end.
45
46 func.func @test_call_i32_f32(%0 : !fir.ref<!fir.type<ti32_f32{i:i32,x:f32}>>) {
47 %1 = fir.load %0 : !fir.ref<!fir.type<ti32_f32{i:i32,x:f32}>>
48 fir.call @test_func_i32_f32(%1) : (!fir.type<ti32_f32{i:i32,x:f32}>) -> ()
49 return
50 }
51 func.func private @test_func_i32_f32(%0 : !fir.type<ti32_f32{i:i32,x:f32}>) -> () {
52 return
53 }
54
55 func.func @test_call_i32_i16(%0 : !fir.ref<!fir.type<ti32_i16{i:i32,x:i16}>>) {
56 %1 = fir.load %0 : !fir.ref<!fir.type<ti32_i16{i:i32,x:i16}>>
57 fir.call @test_func_i32_i16(%1) : (!fir.type<ti32_i16{i:i32,x:i16}>) -> ()
58 return
59 }
60 func.func private @test_func_i32_i16(%0 : !fir.type<ti32_i16{i:i32,x:i16}>) -> () {
61 return
62 }
63
64 func.func @test_call_f16_i16(%0 : !fir.ref<!fir.type<tf16_i16{i:f16,x:i16}>>) {
65 %1 = fir.load %0 : !fir.ref<!fir.type<tf16_i16{i:f16,x:i16}>>
66 fir.call @test_func_f16_i16(%1) : (!fir.type<tf16_i16{i:f16,x:i16}>) -> ()
67 return
68 }
69 func.func private @test_func_f16_i16(%0 : !fir.type<tf16_i16{i:f16,x:i16}>) -> () {
70 return
71 }
72
73 func.func @test_call_f16_f16(%0 : !fir.ref<!fir.type<tf16_f16{i:f16,x:f16}>>) {
74 %1 = fir.load %0 : !fir.ref<!fir.type<tf16_f16{i:f16,x:f16}>>
75 fir.call @test_func_f16_f16(%1) : (!fir.type<tf16_f16{i:f16,x:f16}>) -> ()
76 return
77 }
78 func.func private @test_func_f16_f16(%0 : !fir.type<tf16_f16{i:f16,x:f16}>) -> () {
79 return
80 }
81
82 func.func @test_call_i32_f64(%0 : !fir.ref<!fir.type<ti32_f64{i:i32,x:f64}>>) {
83 %1 = fir.load %0 : !fir.ref<!fir.type<ti32_f64{i:i32,x:f64}>>
84 fir.call @test_func_i32_f64(%1) : (!fir.type<ti32_f64{i:i32,x:f64}>) -> ()
85 return
86 }
87 func.func private @test_func_i32_f64(%0 : !fir.type<ti32_f64{i:i32,x:f64}>) -> () {
88 return
89 }
90
91 func.func @test_call_f64_f32(%0 : !fir.ref<!fir.type<tf64_f32{i:f64,x:f32}>>) {
92 %1 = fir.load %0 : !fir.ref<!fir.type<tf64_f32{i:f64,x:f32}>>
93 fir.call @test_func_f64_f32(%1) : (!fir.type<tf64_f32{i:f64,x:f32}>) -> ()
94 return
95 }
96 func.func private @test_func_f64_f32(%0 : !fir.type<tf64_f32{i:f64,x:f32}>) -> () {
97 return
98 }
99
100 func.func @test_call_f32_i32_f32_f32(%0 : !fir.ref<!fir.type<tf32_i32_f32_f32{i:i32,x:f32,y:f32,z:f32}>>) {
101 %1 = fir.load %0 : !fir.ref<!fir.type<tf32_i32_f32_f32{i:i32,x:f32,y:f32,z:f32}>>
102 fir.call @test_func_f32_i32_f32_f32(%1) : (!fir.type<tf32_i32_f32_f32{i:i32,x:f32,y:f32,z:f32}>) -> ()
103 return
104 }
105 func.func private @test_func_f32_i32_f32_f32(%0 : !fir.type<tf32_i32_f32_f32{i:i32,x:f32,y:f32,z:f32}>) -> () {
106 return
107 }
108
109 func.func @test_call_f64_i32(%before : i16, %0 : !fir.ref<!fir.type<tf64_i32{i:f64,x:i32}>>, %after : f128) {
110 %1 = fir.load %0 : !fir.ref<!fir.type<tf64_i32{i:f64,x:i32}>>
111 fir.call @test_func_f64_i32(%before, %1, %after) : (i16, !fir.type<tf64_i32{i:f64,x:i32}>, f128) -> ()
112 return
113 }
114 func.func private @test_func_f64_i32(%before : i16, %0 : !fir.type<tf64_i32{i:f64,x:i32}>, %after : f128) -> () {
115 return
116 }
117 }
118
119 // CHECK-LABEL: func.func @test_call_i32_f32(
120 // CHECK-SAME: %[[VAL_0:.*]]: !fir.ref<!fir.type<ti32_f32{i:i32,x:f32}>>) {
121 // CHECK-LABEL: func.func private @test_func_i32_f32(
122 // CHECK-SAME: %[[VAL_0:.*]]: i64) {
123 // CHECK-LABEL: func.func @test_call_i32_i16(
124 // CHECK-SAME: %[[VAL_0:.*]]: !fir.ref<!fir.type<ti32_i16{i:i32,x:i16}>>) {
125 // CHECK-LABEL: func.func private @test_func_i32_i16(
126 // CHECK-SAME: %[[VAL_0:.*]]: i64) {
127 // CHECK-LABEL: func.func @test_call_f16_i16(
128 // CHECK-SAME: %[[VAL_0:.*]]: !fir.ref<!fir.type<tf16_i16{i:f16,x:i16}>>) {
129 // CHECK-LABEL: func.func private @test_func_f16_i16(
130 // CHECK-SAME: %[[VAL_0:.*]]: i32) {
131 // CHECK-LABEL: func.func @test_call_f16_f16(
132 // CHECK-SAME: %[[VAL_0:.*]]: !fir.ref<!fir.type<tf16_f16{i:f16,x:f16}>>) {
133 // CHECK-LABEL: func.func private @test_func_f16_f16(
134 // CHECK-SAME: %[[VAL_0:.*]]: f32) {
135 // CHECK-LABEL: func.func @test_call_i32_f64(
136 // CHECK-SAME: %[[VAL_0:.*]]: !fir.ref<!fir.type<ti32_f64{i:i32,x:f64}>>) {
137 // CHECK-LABEL: func.func private @test_func_i32_f64(
138 // CHECK-SAME: %[[VAL_0:.*]]: i64,
139 // CHECK-SAME: %[[VAL_1:.*]]: f64) {
140 // CHECK-LABEL: func.func @test_call_f64_f32(
141 // CHECK-SAME: %[[VAL_0:.*]]: !fir.ref<!fir.type<tf64_f32{i:f64,x:f32}>>) {
142 // CHECK-LABEL: func.func private @test_func_f64_f32(
143 // CHECK-SAME: %[[VAL_0:.*]]: f64,
144 // CHECK-SAME: %[[VAL_1:.*]]: f32) {
145 // CHECK-LABEL: func.func @test_call_f32_i32_f32_f32(
146 // CHECK-SAME: %[[VAL_0:.*]]: !fir.ref<!fir.type<tf32_i32_f32_f32{i:i32,x:f32,y:f32,z:f32}>>) {
147 // CHECK-LABEL: func.func private @test_func_f32_i32_f32_f32(
148 // CHECK-SAME: %[[VAL_0:.*]]: i64,
149 // CHECK-SAME: %[[VAL_1:.*]]: f64) {
150 // CHECK-LABEL: func.func @test_call_f64_i32(
151 // CHECK-SAME: %[[VAL_0:.*]]: i16,
152 // CHECK-SAME: %[[VAL_1:.*]]: !fir.ref<!fir.type<tf64_i32{i:f64,x:i32}>>,
153 // CHECK-SAME: %[[VAL_2:.*]]: f128) {
154 // CHECK-LABEL: func.func private @test_func_f64_i32(
155 // CHECK-SAME: %[[VAL_0:.*]]: i16,
156 // CHECK-SAME: %[[VAL_1:.*]]: f64,
157 // CHECK-SAME: %[[VAL_2:.*]]: i32,
158 // CHECK-SAME: %[[VAL_3:.*]]: f128) {