|
2 | 2 | ; RUN: llc -O3 -mtriple=riscv32 -mattr=+xcvmem -verify-machineinstrs < %s \
|
3 | 3 | ; RUN: | FileCheck %s --check-prefixes=CHECK
|
4 | 4 |
|
5 |
| -define <2 x i32> @lb_ri_inc(i8* %a) { |
| 5 | +define <2 x i32> @lb_ri_inc(ptr %a) { |
6 | 6 | ; CHECK-LABEL: lb_ri_inc:
|
7 | 7 | ; CHECK: # %bb.0:
|
8 | 8 | ; CHECK-NEXT: cv.lb a1, (a0), 42
|
9 | 9 | ; CHECK-NEXT: ret
|
10 |
| - %1 = load i8, i8* %a |
| 10 | + %1 = load i8, ptr %a |
11 | 11 | %2 = sext i8 %1 to i32
|
12 |
| - %3 = getelementptr i8, i8* %a, i32 42 |
13 |
| - %4 = ptrtoint i8* %3 to i32 |
| 12 | + %3 = getelementptr i8, ptr %a, i32 42 |
| 13 | + %4 = ptrtoint ptr %3 to i32 |
14 | 14 | %5 = insertelement <2 x i32> undef, i32 %4, i32 0
|
15 | 15 | %6 = insertelement <2 x i32> %5, i32 %2, i32 1
|
16 | 16 | ret <2 x i32> %6
|
17 | 17 | }
|
18 | 18 |
|
19 |
| -define <2 x i32> @lb_rr_inc(i8* %a, i32 %b) { |
| 19 | +define <2 x i32> @lb_rr_inc(ptr %a, i32 %b) { |
20 | 20 | ; CHECK-LABEL: lb_rr_inc:
|
21 | 21 | ; CHECK: # %bb.0:
|
22 | 22 | ; CHECK-NEXT: cv.lb a1, (a0), a1
|
23 | 23 | ; CHECK-NEXT: ret
|
24 |
| - %1 = load i8, i8* %a |
| 24 | + %1 = load i8, ptr %a |
25 | 25 | %2 = sext i8 %1 to i32
|
26 |
| - %3 = getelementptr i8, i8* %a, i32 %b |
27 |
| - %4 = ptrtoint i8* %3 to i32 |
| 26 | + %3 = getelementptr i8, ptr %a, i32 %b |
| 27 | + %4 = ptrtoint ptr %3 to i32 |
28 | 28 | %5 = insertelement <2 x i32> undef, i32 %4, i32 0
|
29 | 29 | %6 = insertelement <2 x i32> %5, i32 %2, i32 1
|
30 | 30 | ret <2 x i32> %6
|
31 | 31 | }
|
32 | 32 |
|
33 |
| -define i32 @lb_rr(i8* %a, i32 %b) { |
| 33 | +define i32 @lb_rr(ptr %a, i32 %b) { |
34 | 34 | ; CHECK-LABEL: lb_rr:
|
35 | 35 | ; CHECK: # %bb.0:
|
36 | 36 | ; CHECK-NEXT: cv.lb a0, a1(a0)
|
37 | 37 | ; CHECK-NEXT: ret
|
38 |
| - %1 = getelementptr i8, i8* %a, i32 %b |
39 |
| - %2 = load i8, i8* %1 |
| 38 | + %1 = getelementptr i8, ptr %a, i32 %b |
| 39 | + %2 = load i8, ptr %1 |
40 | 40 | %3 = sext i8 %2 to i32
|
41 | 41 | ret i32 %3
|
42 | 42 | }
|
43 | 43 |
|
44 |
| -define <2 x i32> @lbu_ri_inc(i8* %a) { |
| 44 | +define <2 x i32> @lbu_ri_inc(ptr %a) { |
45 | 45 | ; CHECK-LABEL: lbu_ri_inc:
|
46 | 46 | ; CHECK: # %bb.0:
|
47 | 47 | ; CHECK-NEXT: cv.lbu a1, (a0), 42
|
48 | 48 | ; CHECK-NEXT: ret
|
49 |
| - %1 = load i8, i8* %a |
| 49 | + %1 = load i8, ptr %a |
50 | 50 | %2 = zext i8 %1 to i32
|
51 |
| - %3 = getelementptr i8, i8* %a, i32 42 |
52 |
| - %4 = ptrtoint i8* %3 to i32 |
| 51 | + %3 = getelementptr i8, ptr %a, i32 42 |
| 52 | + %4 = ptrtoint ptr %3 to i32 |
53 | 53 | %5 = insertelement <2 x i32> undef, i32 %4, i32 0
|
54 | 54 | %6 = insertelement <2 x i32> %5, i32 %2, i32 1
|
55 | 55 | ret <2 x i32> %6
|
56 | 56 | }
|
57 | 57 |
|
58 |
| -define <2 x i32> @lbu_rr_inc(i8* %a, i32 %b) { |
| 58 | +define <2 x i32> @lbu_rr_inc(ptr %a, i32 %b) { |
59 | 59 | ; CHECK-LABEL: lbu_rr_inc:
|
60 | 60 | ; CHECK: # %bb.0:
|
61 | 61 | ; CHECK-NEXT: cv.lbu a1, (a0), a1
|
62 | 62 | ; CHECK-NEXT: ret
|
63 |
| - %1 = load i8, i8* %a |
| 63 | + %1 = load i8, ptr %a |
64 | 64 | %2 = zext i8 %1 to i32
|
65 |
| - %3 = getelementptr i8, i8* %a, i32 %b |
66 |
| - %4 = ptrtoint i8* %3 to i32 |
| 65 | + %3 = getelementptr i8, ptr %a, i32 %b |
| 66 | + %4 = ptrtoint ptr %3 to i32 |
67 | 67 | %5 = insertelement <2 x i32> undef, i32 %4, i32 0
|
68 | 68 | %6 = insertelement <2 x i32> %5, i32 %2, i32 1
|
69 | 69 | ret <2 x i32> %6
|
70 | 70 | }
|
71 | 71 |
|
72 |
| -define i32 @lbu_rr(i8* %a, i32 %b) { |
| 72 | +define i32 @lbu_rr(ptr %a, i32 %b) { |
73 | 73 | ; CHECK-LABEL: lbu_rr:
|
74 | 74 | ; CHECK: # %bb.0:
|
75 | 75 | ; CHECK-NEXT: cv.lbu a0, a1(a0)
|
76 | 76 | ; CHECK-NEXT: ret
|
77 |
| - %1 = getelementptr i8, i8* %a, i32 %b |
78 |
| - %2 = load i8, i8* %1 |
| 77 | + %1 = getelementptr i8, ptr %a, i32 %b |
| 78 | + %2 = load i8, ptr %1 |
79 | 79 | %3 = zext i8 %2 to i32
|
80 | 80 | ret i32 %3
|
81 | 81 | }
|
82 | 82 |
|
83 |
| -define <2 x i32> @lh_ri_inc(i16* %a) { |
| 83 | +define <2 x i32> @lh_ri_inc(ptr %a) { |
84 | 84 | ; CHECK-LABEL: lh_ri_inc:
|
85 | 85 | ; CHECK: # %bb.0:
|
86 | 86 | ; CHECK-NEXT: cv.lh a1, (a0), 84
|
87 | 87 | ; CHECK-NEXT: ret
|
88 |
| - %1 = load i16, i16* %a |
| 88 | + %1 = load i16, ptr %a |
89 | 89 | %2 = sext i16 %1 to i32
|
90 |
| - %3 = getelementptr i16, i16* %a, i32 42 |
91 |
| - %4 = ptrtoint i16* %3 to i32 |
| 90 | + %3 = getelementptr i16, ptr %a, i32 42 |
| 91 | + %4 = ptrtoint ptr %3 to i32 |
92 | 92 | %5 = insertelement <2 x i32> undef, i32 %4, i32 0
|
93 | 93 | %6 = insertelement <2 x i32> %5, i32 %2, i32 1
|
94 | 94 | ret <2 x i32> %6
|
95 | 95 | }
|
96 | 96 |
|
97 |
| -define <2 x i32> @lh_rr_inc(i16* %a, i32 %b) { |
| 97 | +define <2 x i32> @lh_rr_inc(ptr %a, i32 %b) { |
98 | 98 | ; CHECK-LABEL: lh_rr_inc:
|
99 | 99 | ; CHECK: # %bb.0:
|
100 | 100 | ; CHECK-NEXT: slli a1, a1, 1
|
101 | 101 | ; CHECK-NEXT: cv.lh a1, (a0), a1
|
102 | 102 | ; CHECK-NEXT: ret
|
103 |
| - %1 = load i16, i16* %a |
| 103 | + %1 = load i16, ptr %a |
104 | 104 | %2 = sext i16 %1 to i32
|
105 |
| - %3 = getelementptr i16, i16* %a, i32 %b |
106 |
| - %4 = ptrtoint i16* %3 to i32 |
| 105 | + %3 = getelementptr i16, ptr %a, i32 %b |
| 106 | + %4 = ptrtoint ptr %3 to i32 |
107 | 107 | %5 = insertelement <2 x i32> undef, i32 %4, i32 0
|
108 | 108 | %6 = insertelement <2 x i32> %5, i32 %2, i32 1
|
109 | 109 | ret <2 x i32> %6
|
110 | 110 | }
|
111 | 111 |
|
112 |
| -define i32 @lh_rr(i16* %a, i32 %b) { |
| 112 | +define i32 @lh_rr(ptr %a, i32 %b) { |
113 | 113 | ; CHECK-LABEL: lh_rr:
|
114 | 114 | ; CHECK: # %bb.0:
|
115 | 115 | ; CHECK-NEXT: slli a1, a1, 1
|
116 | 116 | ; CHECK-NEXT: cv.lh a0, a1(a0)
|
117 | 117 | ; CHECK-NEXT: ret
|
118 |
| - %1 = getelementptr i16, i16* %a, i32 %b |
119 |
| - %2 = load i16, i16* %1 |
| 118 | + %1 = getelementptr i16, ptr %a, i32 %b |
| 119 | + %2 = load i16, ptr %1 |
120 | 120 | %3 = sext i16 %2 to i32
|
121 | 121 | ret i32 %3
|
122 | 122 | }
|
123 | 123 |
|
124 |
| -define <2 x i32> @lhu_ri_inc(i16* %a) { |
| 124 | +define <2 x i32> @lhu_ri_inc(ptr %a) { |
125 | 125 | ; CHECK-LABEL: lhu_ri_inc:
|
126 | 126 | ; CHECK: # %bb.0:
|
127 | 127 | ; CHECK-NEXT: cv.lhu a1, (a0), 84
|
128 | 128 | ; CHECK-NEXT: ret
|
129 |
| - %1 = load i16, i16* %a |
| 129 | + %1 = load i16, ptr %a |
130 | 130 | %2 = zext i16 %1 to i32
|
131 |
| - %3 = getelementptr i16, i16* %a, i32 42 |
132 |
| - %4 = ptrtoint i16* %3 to i32 |
| 131 | + %3 = getelementptr i16, ptr %a, i32 42 |
| 132 | + %4 = ptrtoint ptr %3 to i32 |
133 | 133 | %5 = insertelement <2 x i32> undef, i32 %4, i32 0
|
134 | 134 | %6 = insertelement <2 x i32> %5, i32 %2, i32 1
|
135 | 135 | ret <2 x i32> %6
|
136 | 136 | }
|
137 | 137 |
|
138 |
| -define <2 x i32> @lhu_rr_inc(i16* %a, i32 %b) { |
| 138 | +define <2 x i32> @lhu_rr_inc(ptr %a, i32 %b) { |
139 | 139 | ; CHECK-LABEL: lhu_rr_inc:
|
140 | 140 | ; CHECK: # %bb.0:
|
141 | 141 | ; CHECK-NEXT: slli a1, a1, 1
|
142 | 142 | ; CHECK-NEXT: cv.lhu a1, (a0), a1
|
143 | 143 | ; CHECK-NEXT: ret
|
144 |
| - %1 = load i16, i16* %a |
| 144 | + %1 = load i16, ptr %a |
145 | 145 | %2 = zext i16 %1 to i32
|
146 |
| - %3 = getelementptr i16, i16* %a, i32 %b |
147 |
| - %4 = ptrtoint i16* %3 to i32 |
| 146 | + %3 = getelementptr i16, ptr %a, i32 %b |
| 147 | + %4 = ptrtoint ptr %3 to i32 |
148 | 148 | %5 = insertelement <2 x i32> undef, i32 %4, i32 0
|
149 | 149 | %6 = insertelement <2 x i32> %5, i32 %2, i32 1
|
150 | 150 | ret <2 x i32> %6
|
151 | 151 | }
|
152 | 152 |
|
153 |
| -define i32 @lhu_rr(i16* %a, i32 %b) { |
| 153 | +define i32 @lhu_rr(ptr %a, i32 %b) { |
154 | 154 | ; CHECK-LABEL: lhu_rr:
|
155 | 155 | ; CHECK: # %bb.0:
|
156 | 156 | ; CHECK-NEXT: slli a1, a1, 1
|
157 | 157 | ; CHECK-NEXT: cv.lhu a0, a1(a0)
|
158 | 158 | ; CHECK-NEXT: ret
|
159 |
| - %1 = getelementptr i16, i16* %a, i32 %b |
160 |
| - %2 = load i16, i16* %1 |
| 159 | + %1 = getelementptr i16, ptr %a, i32 %b |
| 160 | + %2 = load i16, ptr %1 |
161 | 161 | %3 = zext i16 %2 to i32
|
162 | 162 | ret i32 %3
|
163 | 163 | }
|
164 | 164 |
|
165 |
| -define <2 x i32> @lw_ri_inc(i32* %a) { |
| 165 | +define <2 x i32> @lw_ri_inc(ptr %a) { |
166 | 166 | ; CHECK-LABEL: lw_ri_inc:
|
167 | 167 | ; CHECK: # %bb.0:
|
168 | 168 | ; CHECK-NEXT: cv.lw a1, (a0), 168
|
169 | 169 | ; CHECK-NEXT: ret
|
170 |
| - %1 = load i32, i32* %a |
171 |
| - %2 = getelementptr i32, i32* %a, i32 42 |
172 |
| - %3 = ptrtoint i32* %2 to i32 |
| 170 | + %1 = load i32, ptr %a |
| 171 | + %2 = getelementptr i32, ptr %a, i32 42 |
| 172 | + %3 = ptrtoint ptr %2 to i32 |
173 | 173 | %4 = insertelement <2 x i32> undef, i32 %3, i32 0
|
174 | 174 | %5 = insertelement <2 x i32> %4, i32 %1, i32 1
|
175 | 175 | ret <2 x i32> %5
|
176 | 176 | }
|
177 | 177 |
|
178 |
| -define <2 x i32> @lw_rr_inc(i32* %a, i32 %b) { |
| 178 | +define <2 x i32> @lw_rr_inc(ptr %a, i32 %b) { |
179 | 179 | ; CHECK-LABEL: lw_rr_inc:
|
180 | 180 | ; CHECK: # %bb.0:
|
181 | 181 | ; CHECK-NEXT: slli a1, a1, 2
|
182 | 182 | ; CHECK-NEXT: cv.lw a1, (a0), a1
|
183 | 183 | ; CHECK-NEXT: ret
|
184 |
| - %1 = load i32, i32* %a |
185 |
| - %2 = getelementptr i32, i32* %a, i32 %b |
186 |
| - %3 = ptrtoint i32* %2 to i32 |
| 184 | + %1 = load i32, ptr %a |
| 185 | + %2 = getelementptr i32, ptr %a, i32 %b |
| 186 | + %3 = ptrtoint ptr %2 to i32 |
187 | 187 | %4 = insertelement <2 x i32> undef, i32 %3, i32 0
|
188 | 188 | %5 = insertelement <2 x i32> %4, i32 %1, i32 1
|
189 | 189 | ret <2 x i32> %5
|
190 | 190 | }
|
191 | 191 |
|
192 |
| -define i32 @lw_rr(i32* %a, i32 %b) { |
| 192 | +define i32 @lw_rr(ptr %a, i32 %b) { |
193 | 193 | ; CHECK-LABEL: lw_rr:
|
194 | 194 | ; CHECK: # %bb.0:
|
195 | 195 | ; CHECK-NEXT: slli a1, a1, 2
|
196 | 196 | ; CHECK-NEXT: cv.lw a0, a1(a0)
|
197 | 197 | ; CHECK-NEXT: ret
|
198 |
| - %1 = getelementptr i32, i32* %a, i32 %b |
199 |
| - %2 = load i32, i32* %1 |
| 198 | + %1 = getelementptr i32, ptr %a, i32 %b |
| 199 | + %2 = load i32, ptr %1 |
200 | 200 | ret i32 %2
|
201 | 201 | }
|
202 | 202 |
|
203 |
| -define i8* @sb_ri_inc(i8* %a, i8 %b) { |
| 203 | +define ptr @sb_ri_inc(ptr %a, i8 %b) { |
204 | 204 | ; CHECK-LABEL: sb_ri_inc:
|
205 | 205 | ; CHECK: # %bb.0:
|
206 | 206 | ; CHECK-NEXT: cv.sb a1, (a0), 42
|
207 | 207 | ; CHECK-NEXT: ret
|
208 |
| - store i8 %b, i8* %a |
209 |
| - %1 = getelementptr i8, i8* %a, i32 42 |
210 |
| - ret i8* %1 |
| 208 | + store i8 %b, ptr %a |
| 209 | + %1 = getelementptr i8, ptr %a, i32 42 |
| 210 | + ret ptr %1 |
211 | 211 | }
|
212 | 212 |
|
213 |
| -define i8* @sb_rr_inc(i8* %a, i8 %b, i32 %c) { |
| 213 | +define ptr @sb_rr_inc(ptr %a, i8 %b, i32 %c) { |
214 | 214 | ; CHECK-LABEL: sb_rr_inc:
|
215 | 215 | ; CHECK: # %bb.0:
|
216 | 216 | ; CHECK-NEXT: cv.sb a1, (a0), a2
|
217 | 217 | ; CHECK-NEXT: ret
|
218 |
| - store i8 %b, i8* %a |
219 |
| - %1 = getelementptr i8, i8* %a, i32 %c |
220 |
| - ret i8* %1 |
| 218 | + store i8 %b, ptr %a |
| 219 | + %1 = getelementptr i8, ptr %a, i32 %c |
| 220 | + ret ptr %1 |
221 | 221 | }
|
222 | 222 |
|
223 |
| -define void @sb_rr(i8* %a, i8 %b, i32 %c) { |
| 223 | +define void @sb_rr(ptr %a, i8 %b, i32 %c) { |
224 | 224 | ; CHECK-LABEL: sb_rr:
|
225 | 225 | ; CHECK: # %bb.0:
|
226 | 226 | ; CHECK-NEXT: cv.sb a1, a2(a0)
|
227 | 227 | ; CHECK-NEXT: ret
|
228 |
| - %1 = getelementptr i8, i8* %a, i32 %c |
229 |
| - store i8 %b, i8* %1 |
| 228 | + %1 = getelementptr i8, ptr %a, i32 %c |
| 229 | + store i8 %b, ptr %1 |
230 | 230 | ret void
|
231 | 231 | }
|
232 | 232 |
|
233 |
| -define i16* @sh_ri_inc(i16* %a, i16 %b) { |
| 233 | +define ptr @sh_ri_inc(ptr %a, i16 %b) { |
234 | 234 | ; CHECK-LABEL: sh_ri_inc:
|
235 | 235 | ; CHECK: # %bb.0:
|
236 | 236 | ; CHECK-NEXT: cv.sh a1, (a0), 84
|
237 | 237 | ; CHECK-NEXT: ret
|
238 |
| - store i16 %b, i16* %a |
239 |
| - %1 = getelementptr i16, i16* %a, i32 42 |
240 |
| - ret i16* %1 |
| 238 | + store i16 %b, ptr %a |
| 239 | + %1 = getelementptr i16, ptr %a, i32 42 |
| 240 | + ret ptr %1 |
241 | 241 | }
|
242 | 242 |
|
243 |
| -define i16* @sh_rr_inc(i16* %a, i16 %b, i32 %c) { |
| 243 | +define ptr @sh_rr_inc(ptr %a, i16 %b, i32 %c) { |
244 | 244 | ; CHECK-LABEL: sh_rr_inc:
|
245 | 245 | ; CHECK: # %bb.0:
|
246 | 246 | ; CHECK-NEXT: slli a2, a2, 1
|
247 | 247 | ; CHECK-NEXT: cv.sh a1, (a0), a2
|
248 | 248 | ; CHECK-NEXT: ret
|
249 |
| - store i16 %b, i16* %a |
250 |
| - %1 = getelementptr i16, i16* %a, i32 %c |
251 |
| - ret i16* %1 |
| 249 | + store i16 %b, ptr %a |
| 250 | + %1 = getelementptr i16, ptr %a, i32 %c |
| 251 | + ret ptr %1 |
252 | 252 | }
|
253 | 253 |
|
254 |
| -define void @sh_rr(i16* %a, i16 %b, i32 %c) { |
| 254 | +define void @sh_rr(ptr %a, i16 %b, i32 %c) { |
255 | 255 | ; CHECK-LABEL: sh_rr:
|
256 | 256 | ; CHECK: # %bb.0:
|
257 | 257 | ; CHECK-NEXT: slli a2, a2, 1
|
258 | 258 | ; CHECK-NEXT: cv.sh a1, a2(a0)
|
259 | 259 | ; CHECK-NEXT: ret
|
260 |
| - %1 = getelementptr i16, i16* %a, i32 %c |
261 |
| - store i16 %b, i16* %1 |
| 260 | + %1 = getelementptr i16, ptr %a, i32 %c |
| 261 | + store i16 %b, ptr %1 |
262 | 262 | ret void
|
263 | 263 | }
|
264 | 264 |
|
265 |
| -define i32* @sw_ri_inc(i32* %a, i32 %b) { |
| 265 | +define ptr @sw_ri_inc(ptr %a, i32 %b) { |
266 | 266 | ; CHECK-LABEL: sw_ri_inc:
|
267 | 267 | ; CHECK: # %bb.0:
|
268 | 268 | ; CHECK-NEXT: cv.sw a1, (a0), 168
|
269 | 269 | ; CHECK-NEXT: ret
|
270 |
| - store i32 %b, i32* %a |
271 |
| - %1 = getelementptr i32, i32* %a, i32 42 |
272 |
| - ret i32* %1 |
| 270 | + store i32 %b, ptr %a |
| 271 | + %1 = getelementptr i32, ptr %a, i32 42 |
| 272 | + ret ptr %1 |
273 | 273 | }
|
274 | 274 |
|
275 |
| -define i32* @sw_rr_inc(i32* %a, i32 %b, i32 %c) { |
| 275 | +define ptr @sw_rr_inc(ptr %a, i32 %b, i32 %c) { |
276 | 276 | ; CHECK-LABEL: sw_rr_inc:
|
277 | 277 | ; CHECK: # %bb.0:
|
278 | 278 | ; CHECK-NEXT: slli a2, a2, 2
|
279 | 279 | ; CHECK-NEXT: cv.sw a1, (a0), a2
|
280 | 280 | ; CHECK-NEXT: ret
|
281 |
| - store i32 %b, i32* %a |
282 |
| - %1 = getelementptr i32, i32* %a, i32 %c |
283 |
| - ret i32* %1 |
| 281 | + store i32 %b, ptr %a |
| 282 | + %1 = getelementptr i32, ptr %a, i32 %c |
| 283 | + ret ptr %1 |
284 | 284 | }
|
285 | 285 |
|
286 |
| -define void @sw_rr(i32* %a, i32 %b, i32 %c) { |
| 286 | +define void @sw_rr(ptr %a, i32 %b, i32 %c) { |
287 | 287 | ; CHECK-LABEL: sw_rr:
|
288 | 288 | ; CHECK: # %bb.0:
|
289 | 289 | ; CHECK-NEXT: slli a2, a2, 2
|
290 | 290 | ; CHECK-NEXT: cv.sw a1, a2(a0)
|
291 | 291 | ; CHECK-NEXT: ret
|
292 |
| - %1 = getelementptr i32, i32* %a, i32 %c |
293 |
| - store i32 %b, i32* %1 |
| 292 | + %1 = getelementptr i32, ptr %a, i32 %c |
| 293 | + store i32 %b, ptr %1 |
294 | 294 | ret void
|
295 | 295 | }
|
0 commit comments