Skip to content

Commit 31c32cf

Browse files
ghehgghehg
committed
resolve merge conflict
1 parent 95b1540 commit 31c32cf

File tree

1 file changed

+45
-142
lines changed

1 file changed

+45
-142
lines changed

‎clang/test/CIR/CodeGen/AArch64/neon-misc.c

+45-142
Original file line numberDiff line numberDiff line change
@@ -25,14 +25,8 @@ uint8x8_t test_vset_lane_u8(uint8_t a, uint8x8_t b) {
2525
// CIR: {{%.*}} = cir.vec.insert {{%.*}}, {{%.*}}[[[IDX]] : !s32i] : !cir.vector<!s8i x 8>
2626

2727
// LLVM: {{.*}}test_vset_lane_u8(i8{{.*}}[[A:%.*]], <8 x i8>{{.*}}[[B:%.*]])
28-
// LLVM: [[A_ADR:%.*]] = alloca i8, i64 1, align 1
29-
// LLVM: [[B_ADR:%.*]] = alloca <8 x i8>, i64 1, align 8
30-
// LLVM: store i8 [[A]], ptr [[A_ADR]], align 1
31-
// LLVM: store <8 x i8> [[B]], ptr [[B_ADR]], align 8
32-
// LLVM: [[INTRN_ARG0:%.*]] = load i8, ptr [[A_ADR]], align 1
33-
// LLVM: [[INTRN_ARG1:%.*]] = load <8 x i8>, ptr [[B_ADR]], align 8
34-
// LLVM: [[INTRN_RES:%.*]] = insertelement <8 x i8> [[INTRN_ARG1]], i8 [[INTRN_ARG0]], i32 7
35-
// LLVM: ret <8 x i8> {{%.*}}
28+
// LLVM: [[INTRN_RES:%.*]] = insertelement <8 x i8> [[B]], i8 [[A]], i32 7
29+
// LLVM: ret <8 x i8> [[INTRN_RES]]
3630

3731
uint16x4_t test_vset_lane_u16(uint16_t a, uint16x4_t b) {
3832
return vset_lane_u16(a, b, 3);
@@ -43,14 +37,8 @@ uint16x4_t test_vset_lane_u16(uint16_t a, uint16x4_t b) {
4337
// CIR: {{%.*}} = cir.vec.insert {{%.*}}, {{%.*}}[[[IDX]] : !s32i] : !cir.vector<!s16i x 4>
4438

4539
// LLVM: {{.*}}test_vset_lane_u16(i16{{.*}}[[A:%.*]], <4 x i16>{{.*}}[[B:%.*]])
46-
// LLVM: [[A_ADR:%.*]] = alloca i16, i64 1, align 2
47-
// LLVM: [[B_ADR:%.*]] = alloca <4 x i16>, i64 1, align 8
48-
// LLVM: store i16 [[A]], ptr [[A_ADR]], align 2
49-
// LLVM: store <4 x i16> [[B]], ptr [[B_ADR]], align 8
50-
// LLVM: [[INTRN_ARG0:%.*]] = load i16, ptr [[A_ADR]], align 2
51-
// LLVM: [[INTRN_ARG1:%.*]] = load <4 x i16>, ptr [[B_ADR]], align 8
52-
// LLVM: [[INTRN_RES:%.*]] = insertelement <4 x i16> [[INTRN_ARG1]], i16 [[INTRN_ARG0]], i32 3
53-
// LLVM: ret <4 x i16> {{%.*}}
40+
// LLVM: [[INTRN_RES:%.*]] = insertelement <4 x i16> [[B]], i16 [[A]], i32 3
41+
// LLVM: ret <4 x i16> [[INTRN_RES]]
5442

5543
uint32x2_t test_vset_lane_u32(uint32_t a, uint32x2_t b) {
5644
return vset_lane_u32(a, b, 1);
@@ -61,15 +49,8 @@ uint32x2_t test_vset_lane_u32(uint32_t a, uint32x2_t b) {
6149
// CIR: {{%.*}} = cir.vec.insert {{%.*}}, {{%.*}}[[[IDX]] : !s32i] : !cir.vector<!s32i x 2>
6250

6351
// LLVM: {{.*}}test_vset_lane_u32(i32{{.*}}[[A:%.*]], <2 x i32>{{.*}}[[B:%.*]])
64-
// LLVM: [[A_ADR:%.*]] = alloca i32, i64 1, align 4
65-
// LLVM: [[B_ADR:%.*]] = alloca <2 x i32>, i64 1, align 8
66-
// LLVM: store i32 [[A]], ptr [[A_ADR]], align 4
67-
// LLVM: store <2 x i32> [[B]], ptr [[B_ADR]], align 8
68-
// LLVM: [[INTRN_ARG0:%.*]] = load i32, ptr [[A_ADR]], align 4
69-
// LLVM: [[INTRN_ARG1:%.*]] = load <2 x i32>, ptr [[B_ADR]], align 8
70-
// LLVM: [[INTRN_RES:%.*]] = insertelement <2 x i32> [[INTRN_ARG1]], i32 [[INTRN_ARG0]], i32 1
71-
// LLVM: ret <2 x i32> {{%.*}}
72-
52+
// LLVM: [[INTRN_RES:%.*]] = insertelement <2 x i32> [[B]], i32 [[A]], i32 1
53+
// LLVM: ret <2 x i32> [[INTRN_RES]]
7354

7455
uint64x1_t test_vset_lane_u64(uint64_t a, uint64x1_t b) {
7556
return vset_lane_u64(a, b, 0);
@@ -80,14 +61,8 @@ uint64x1_t test_vset_lane_u64(uint64_t a, uint64x1_t b) {
8061
// CIR: {{%.*}} = cir.vec.insert {{%.*}}, {{%.*}}[[[IDX]] : !s32i] : !cir.vector<!s64i x 1>
8162

8263
// LLVM: {{.*}}test_vset_lane_u64(i64{{.*}}[[A:%.*]], <1 x i64>{{.*}}[[B:%.*]])
83-
// LLVM: [[A_ADR:%.*]] = alloca i64, i64 1, align 8
84-
// LLVM: [[B_ADR:%.*]] = alloca <1 x i64>, i64 1, align 8
85-
// LLVM: store i64 [[A]], ptr [[A_ADR]], align 8
86-
// LLVM: store <1 x i64> [[B]], ptr [[B_ADR]], align 8
87-
// LLVM: [[INTRN_ARG0:%.*]] = load i64, ptr [[A_ADR]], align 8
88-
// LLVM: [[INTRN_ARG1:%.*]] = load <1 x i64>, ptr [[B_ADR]], align 8
89-
// LLVM: [[INTRN_RES:%.*]] = insertelement <1 x i64> [[INTRN_ARG1]], i64 [[INTRN_ARG0]], i32 0
90-
// LLVM: ret <1 x i64> {{%.*}}
64+
// LLVM: [[INTRN_RES:%.*]] = insertelement <1 x i64> [[B]], i64 [[A]], i32 0
65+
// LLVM: ret <1 x i64> [[INTRN_RES]]
9166

9267
float32x2_t test_vset_lane_f32(float32_t a, float32x2_t b) {
9368
return vset_lane_f32(a, b, 1);
@@ -98,14 +73,8 @@ float32x2_t test_vset_lane_f32(float32_t a, float32x2_t b) {
9873
// CIR: {{%.*}} = cir.vec.insert {{%.*}}, {{%.*}}[[[IDX]] : !s32i] : !cir.vector<!cir.float x 2>
9974

10075
// LLVM: {{.*}}test_vset_lane_f32(float{{.*}}[[A:%.*]], <2 x float>{{.*}}[[B:%.*]])
101-
// LLVM: [[A_ADR:%.*]] = alloca float, i64 1, align 4
102-
// LLVM: [[B_ADR:%.*]] = alloca <2 x float>, i64 1, align 8
103-
// LLVM: store float [[A]], ptr [[A_ADR]], align 4
104-
// LLVM: store <2 x float> [[B]], ptr [[B_ADR]], align 8
105-
// LLVM: [[INTRN_ARG0:%.*]] = load float, ptr [[A_ADR]], align 4
106-
// LLVM: [[INTRN_ARG1:%.*]] = load <2 x float>, ptr [[B_ADR]], align 8
107-
// LLVM: [[INTRN_RES:%.*]] = insertelement <2 x float> [[INTRN_ARG1]], float [[INTRN_ARG0]], i32 1
108-
// LLVM: ret <2 x float> {{%.*}}
76+
// LLVM: [[INTRN_RES:%.*]] = insertelement <2 x float> [[B]], float [[A]], i32 1
77+
// LLVM: ret <2 x float> [[INTRN_RES]]
10978

11079
uint8x16_t test_vsetq_lane_u8(uint8_t a, uint8x16_t b) {
11180
return vsetq_lane_u8(a, b, 15);
@@ -116,14 +85,8 @@ uint8x16_t test_vsetq_lane_u8(uint8_t a, uint8x16_t b) {
11685
// CIR: {{%.*}} = cir.vec.insert {{%.*}}, {{%.*}}[[[IDX]] : !s32i] : !cir.vector<!s8i x 16>
11786

11887
// LLVM: {{.*}}test_vsetq_lane_u8(i8{{.*}}[[A:%.*]], <16 x i8>{{.*}}[[B:%.*]])
119-
// LLVM: [[A_ADR:%.*]] = alloca i8, i64 1, align 1
120-
// LLVM: [[B_ADR:%.*]] = alloca <16 x i8>, i64 1, align 16
121-
// LLVM: store i8 [[A]], ptr [[A_ADR]], align 1
122-
// LLVM: store <16 x i8> [[B]], ptr [[B_ADR]], align 16
123-
// LLVM: [[INTRN_ARG0:%.*]] = load i8, ptr [[A_ADR]], align 1
124-
// LLVM: [[INTRN_ARG1:%.*]] = load <16 x i8>, ptr [[B_ADR]], align 16
125-
// LLVM: [[INTRN_RES:%.*]] = insertelement <16 x i8> [[INTRN_ARG1]], i8 [[INTRN_ARG0]], i32 15
126-
// LLVM: ret <16 x i8> {{%.*}}
88+
// LLVM: [[INTRN_RES:%.*]] = insertelement <16 x i8> [[B]], i8 [[A]], i32 15
89+
// LLVM: ret <16 x i8> [[INTRN_RES]]
12790

12891
uint16x8_t test_vsetq_lane_u16(uint16_t a, uint16x8_t b) {
12992
return vsetq_lane_u16(a, b, 7);
@@ -134,14 +97,8 @@ uint16x8_t test_vsetq_lane_u16(uint16_t a, uint16x8_t b) {
13497
// CIR: {{%.*}} = cir.vec.insert {{%.*}}, {{%.*}}[[[IDX]] : !s32i] : !cir.vector<!s16i x 8>
13598

13699
// LLVM: {{.*}}test_vsetq_lane_u16(i16{{.*}}[[A:%.*]], <8 x i16>{{.*}}[[B:%.*]])
137-
// LLVM: [[A_ADR:%.*]] = alloca i16, i64 1, align 2
138-
// LLVM: [[B_ADR:%.*]] = alloca <8 x i16>, i64 1, align 16
139-
// LLVM: store i16 [[A]], ptr [[A_ADR]], align 2
140-
// LLVM: store <8 x i16> [[B]], ptr [[B_ADR]], align 16
141-
// LLVM: [[INTRN_ARG0:%.*]] = load i16, ptr [[A_ADR]], align 2
142-
// LLVM: [[INTRN_ARG1:%.*]] = load <8 x i16>, ptr [[B_ADR]], align 16
143-
// LLVM: [[INTRN_RES:%.*]] = insertelement <8 x i16> [[INTRN_ARG1]], i16 [[INTRN_ARG0]], i32 7
144-
// LLVM: ret <8 x i16> {{%.*}}
100+
// LLVM: [[INTRN_RES:%.*]] = insertelement <8 x i16> [[B]], i16 [[A]], i32 7
101+
// LLVM: ret <8 x i16> [[INTRN_RES]]
145102

146103
uint32x4_t test_vsetq_lane_u32(uint32_t a, uint32x4_t b) {
147104
return vsetq_lane_u32(a, b, 3);
@@ -152,14 +109,8 @@ uint32x4_t test_vsetq_lane_u32(uint32_t a, uint32x4_t b) {
152109
// CIR: {{%.*}} = cir.vec.insert {{%.*}}, {{%.*}}[[[IDX]] : !s32i] : !cir.vector<!s32i x 4>
153110

154111
// LLVM: {{.*}}test_vsetq_lane_u32(i32{{.*}}[[A:%.*]], <4 x i32>{{.*}}[[B:%.*]])
155-
// LLVM: [[A_ADR:%.*]] = alloca i32, i64 1, align 4
156-
// LLVM: [[B_ADR:%.*]] = alloca <4 x i32>, i64 1, align 16
157-
// LLVM: store i32 [[A]], ptr [[A_ADR]], align 4
158-
// LLVM: store <4 x i32> [[B]], ptr [[B_ADR]], align 16
159-
// LLVM: [[INTRN_ARG0:%.*]] = load i32, ptr [[A_ADR]], align 4
160-
// LLVM: [[INTRN_ARG1:%.*]] = load <4 x i32>, ptr [[B_ADR]], align 16
161-
// LLVM: [[INTRN_RES:%.*]] = insertelement <4 x i32> [[INTRN_ARG1]], i32 [[INTRN_ARG0]], i32 3
162-
// LLVM: ret <4 x i32> {{%.*}}
112+
// LLVM: [[INTRN_RES:%.*]] = insertelement <4 x i32> [[B]], i32 [[A]], i32 3
113+
// LLVM: ret <4 x i32> [[INTRN_RES]]
163114

164115
int64x2_t test_vsetq_lane_s64(int64_t a, int64x2_t b) {
165116
return vsetq_lane_s64(a, b, 1);
@@ -170,14 +121,8 @@ int64x2_t test_vsetq_lane_s64(int64_t a, int64x2_t b) {
170121
// CIR: {{%.*}} = cir.vec.insert {{%.*}}, {{%.*}}[[[IDX]] : !s32i] : !cir.vector<!s64i x 2>
171122

172123
// LLVM: {{.*}}test_vsetq_lane_s64(i64{{.*}}[[A:%.*]], <2 x i64>{{.*}}[[B:%.*]])
173-
// LLVM: [[A_ADR:%.*]] = alloca i64, i64 1, align 8
174-
// LLVM: [[B_ADR:%.*]] = alloca <2 x i64>, i64 1, align 16
175-
// LLVM: store i64 [[A]], ptr [[A_ADR]], align 8
176-
// LLVM: store <2 x i64> [[B]], ptr [[B_ADR]], align 16
177-
// LLVM: [[INTRN_ARG0:%.*]] = load i64, ptr [[A_ADR]], align 8
178-
// LLVM: [[INTRN_ARG1:%.*]] = load <2 x i64>, ptr [[B_ADR]], align 16
179-
// LLVM: [[INTRN_RES:%.*]] = insertelement <2 x i64> [[INTRN_ARG1]], i64 [[INTRN_ARG0]], i32 1
180-
// LLVM: ret <2 x i64> {{%.*}}
124+
// LLVM: [[INTRN_RES:%.*]] = insertelement <2 x i64> [[B]], i64 [[A]], i32 1
125+
// LLVM: ret <2 x i64> [[INTRN_RES]]
181126

182127
float32x4_t test_vsetq_lane_f32(float32_t a, float32x4_t b) {
183128
return vsetq_lane_f32(a, b, 3);
@@ -188,14 +133,8 @@ float32x4_t test_vsetq_lane_f32(float32_t a, float32x4_t b) {
188133
// CIR: {{%.*}} = cir.vec.insert {{%.*}}, {{%.*}}[[[IDX]] : !s32i] : !cir.vector<!cir.float x 4>
189134

190135
// LLVM: {{.*}}test_vsetq_lane_f32(float{{.*}}[[A:%.*]], <4 x float>{{.*}}[[B:%.*]])
191-
// LLVM: [[A_ADR:%.*]] = alloca float, i64 1, align 4
192-
// LLVM: [[B_ADR:%.*]] = alloca <4 x float>, i64 1, align 16
193-
// LLVM: store float [[A]], ptr [[A_ADR]], align 4
194-
// LLVM: store <4 x float> [[B]], ptr [[B_ADR]], align 16
195-
// LLVM: [[INTRN_ARG0:%.*]] = load float, ptr [[A_ADR]], align 4
196-
// LLVM: [[INTRN_ARG1:%.*]] = load <4 x float>, ptr [[B_ADR]], align 16
197-
// LLVM: [[INTRN_RES:%.*]] = insertelement <4 x float> [[INTRN_ARG1]], float [[INTRN_ARG0]], i32 3
198-
// LLVM: ret <4 x float> {{%.*}}
136+
// LLVM: [[INTRN_RES:%.*]] = insertelement <4 x float> [[B]], float [[A]], i32 3
137+
// LLVM: ret <4 x float> [[INTRN_RES]]
199138

200139
uint8_t test_vget_lane_u8(uint8x8_t a) {
201140
return vget_lane_u8(a, 7);
@@ -206,11 +145,8 @@ uint8_t test_vget_lane_u8(uint8x8_t a) {
206145
// CIR: {{%.*}} = cir.vec.extract {{%.*}}[[[IDX]] : !s32i] : !cir.vector<!u8i x 8>
207146

208147
// LLVM: {{.*}}test_vget_lane_u8(<8 x i8>{{.*}}[[ARG:%.*]])
209-
// LLVM: [[ARG_SAVE:%.*]] = alloca <8 x i8>, i64 1, align 8
210-
// LLVM: store <8 x i8> [[ARG]], ptr [[ARG_SAVE]], align 8
211-
// LLVM: [[INTRN_ARG:%.*]] = load <8 x i8>, ptr [[ARG_SAVE]], align 8
212-
// LLVM: {{%.*}} = extractelement <8 x i8> [[INTRN_ARG]], i32 7
213-
// LLVM: ret i8 {{%.*}}
148+
// LLVM: [[RES:%.*]] = extractelement <8 x i8> [[ARG]], i32 7
149+
// LLVM: ret i8 [[RES]]
214150

215151
uint8_t test_vgetq_lane_u8(uint8x16_t a) {
216152
return vgetq_lane_u8(a, 15);
@@ -221,11 +157,8 @@ uint8_t test_vgetq_lane_u8(uint8x16_t a) {
221157
// CIR: {{%.*}} = cir.vec.extract {{%.*}}[[[IDX]] : !s32i] : !cir.vector<!u8i x 16>
222158

223159
// LLVM: {{.*}}test_vgetq_lane_u8(<16 x i8>{{.*}}[[ARG:%.*]])
224-
// LLVM: [[ARG_SAVE:%.*]] = alloca <16 x i8>, i64 1, align 16
225-
// LLVM: store <16 x i8> [[ARG]], ptr [[ARG_SAVE]], align 16
226-
// LLVM: [[INTRN_ARG:%.*]] = load <16 x i8>, ptr [[ARG_SAVE]], align 16
227-
// LLVM: {{%.*}} = extractelement <16 x i8> [[INTRN_ARG]], i32 15
228-
// LLVM: ret i8 {{%.*}}
160+
// LLVM: [[RES:%.*]] = extractelement <16 x i8> [[ARG]], i32 15
161+
// LLVM: ret i8 [[RES]]
229162

230163
uint16_t test_vget_lane_u16(uint16x4_t a) {
231164
return vget_lane_u16(a, 3);
@@ -236,11 +169,8 @@ uint16_t test_vget_lane_u16(uint16x4_t a) {
236169
// CIR: {{%.*}} = cir.vec.extract {{%.*}}[[[IDX]] : !s32i] : !cir.vector<!u16i x 4>
237170

238171
// LLVM: {{.*}}test_vget_lane_u16(<4 x i16>{{.*}}[[ARG:%.*]])
239-
// LLVM: [[ARG_SAVE:%.*]] = alloca <4 x i16>, i64 1, align 8
240-
// LLVM: store <4 x i16> [[ARG]], ptr [[ARG_SAVE]], align 8
241-
// LLVM: [[INTRN_ARG:%.*]] = load <4 x i16>, ptr [[ARG_SAVE]], align 8
242-
// LLVM: {{%.*}} = extractelement <4 x i16> [[INTRN_ARG]], i32 3
243-
// LLVM: ret i16 {{%.*}}
172+
// LLVM: [[RES:%.*]] = extractelement <4 x i16> [[ARG]], i32 3
173+
// LLVM: ret i16 [[RES]]
244174

245175
uint16_t test_vgetq_lane_u16(uint16x8_t a) {
246176
return vgetq_lane_u16(a, 7);
@@ -251,11 +181,8 @@ uint16_t test_vgetq_lane_u16(uint16x8_t a) {
251181
// CIR: {{%.*}} = cir.vec.extract {{%.*}}[[[IDX]] : !s32i] : !cir.vector<!u16i x 8>
252182

253183
// LLVM: {{.*}}test_vgetq_lane_u16(<8 x i16>{{.*}}[[ARG:%.*]])
254-
// LLVM: [[ARG_SAVE:%.*]] = alloca <8 x i16>, i64 1, align 16
255-
// LLVM: store <8 x i16> [[ARG]], ptr [[ARG_SAVE]], align 16
256-
// LLVM: [[INTRN_ARG:%.*]] = load <8 x i16>, ptr [[ARG_SAVE]], align 16
257-
// LLVM: {{%.*}} = extractelement <8 x i16> [[INTRN_ARG]], i32 7
258-
// LLVM: ret i16 {{%.*}}
184+
// LLVM: [[RES:%.*]] = extractelement <8 x i16> [[ARG]], i32 7
185+
// LLVM: ret i16 [[RES]]
259186

260187
uint32_t test_vget_lane_u32(uint32x2_t a) {
261188
return vget_lane_u32(a, 1);
@@ -266,11 +193,8 @@ uint32_t test_vget_lane_u32(uint32x2_t a) {
266193
// CIR: {{%.*}} = cir.vec.extract {{%.*}}[[[IDX]] : !s32i] : !cir.vector<!u32i x 2>
267194

268195
// LLVM: {{.*}}test_vget_lane_u32(<2 x i32>{{.*}}[[ARG:%.*]])
269-
// LLVM: [[ARG_SAVE:%.*]] = alloca <2 x i32>, i64 1, align 8
270-
// LLVM: store <2 x i32> [[ARG]], ptr [[ARG_SAVE]], align 8
271-
// LLVM: [[INTRN_ARG:%.*]] = load <2 x i32>, ptr [[ARG_SAVE]], align 8
272-
// LLVM: {{%.*}} = extractelement <2 x i32> [[INTRN_ARG]], i32 1
273-
// LLVM: ret i32 {{%.*}}
196+
// LLVM: [[RES:%.*]] = extractelement <2 x i32> [[ARG]], i32 1
197+
// LLVM: ret i32 [[RES]]
274198

275199
uint32_t test_vgetq_lane_u32(uint32x4_t a) {
276200
return vgetq_lane_u32(a, 3);
@@ -281,11 +205,8 @@ uint32_t test_vgetq_lane_u32(uint32x4_t a) {
281205
// CIR: {{%.*}} = cir.vec.extract {{%.*}}[[[IDX]] : !s32i] : !cir.vector<!u32i x 4>
282206

283207
// LLVM: {{.*}}test_vgetq_lane_u32(<4 x i32>{{.*}}[[ARG:%.*]])
284-
// LLVM: [[ARG_SAVE:%.*]] = alloca <4 x i32>, i64 1, align 16
285-
// LLVM: store <4 x i32> [[ARG]], ptr [[ARG_SAVE]], align 16
286-
// LLVM: [[INTRN_ARG:%.*]] = load <4 x i32>, ptr [[ARG_SAVE]], align 16
287-
// LLVM: {{%.*}} = extractelement <4 x i32> [[INTRN_ARG]], i32 3
288-
// LLVM: ret i32 {{%.*}}
208+
// LLVM: [[RES:%.*]] = extractelement <4 x i32> [[ARG]], i32 3
209+
// LLVM: ret i32 [[RES]]
289210

290211
uint64_t test_vget_lane_u64(uint64x1_t a) {
291212
return vget_lane_u64(a, 0);
@@ -295,12 +216,9 @@ uint64_t test_vget_lane_u64(uint64x1_t a) {
295216
// CIR: [[IDX:%.*]] = cir.const #cir.int<0> : !s32i
296217
// CIR: {{%.*}} = cir.vec.extract {{%.*}}[[[IDX]] : !s32i] : !cir.vector<!u64i x 1>
297218

298-
// LLVM: {{.*}}est_vget_lane_u64(<1 x i64>{{.*}}[[ARG:%.*]])
299-
// LLVM: [[ARG_SAVE:%.*]] = alloca <1 x i64>, i64 1, align 8
300-
// LLVM: store <1 x i64> [[ARG]], ptr [[ARG_SAVE]], align 8
301-
// LLVM: [[INTRN_ARG:%.*]] = load <1 x i64>, ptr [[ARG_SAVE]], align 8
302-
// LLVM: {{%.*}} = extractelement <1 x i64> [[INTRN_ARG]], i32 0
303-
// LLVM: ret i64 {{%.*}}
219+
// LLVM: {{.*}}test_vget_lane_u64(<1 x i64>{{.*}}[[ARG:%.*]])
220+
// LLVM: [[RES:%.*]] = extractelement <1 x i64> [[ARG]], i32 0
221+
// LLVM: ret i64 [[RES]]
304222

305223
uint64_t test_vgetq_lane_u64(uint64x2_t a) {
306224
return vgetq_lane_u64(a, 1);
@@ -311,11 +229,8 @@ uint64_t test_vgetq_lane_u64(uint64x2_t a) {
311229
// CIR: {{%.*}} = cir.vec.extract {{%.*}}[[[IDX]] : !s32i] : !cir.vector<!u64i x 2>
312230

313231
// LLVM: {{.*}}test_vgetq_lane_u64(<2 x i64>{{.*}}[[ARG:%.*]])
314-
// LLVM: [[ARG_SAVE:%.*]] = alloca <2 x i64>, i64 1, align 16
315-
// LLVM: store <2 x i64> [[ARG]], ptr [[ARG_SAVE]], align 16
316-
// LLVM: [[INTRN_ARG:%.*]] = load <2 x i64>, ptr [[ARG_SAVE]], align 16
317-
// LLVM: {{%.*}} = extractelement <2 x i64> [[INTRN_ARG]], i32 1
318-
// LLVM: ret i64 {{%.*}}
232+
// LLVM: [[RES:%.*]] = extractelement <2 x i64> [[ARG]], i32 1
233+
// LLVM: ret i64 [[RES]]
319234

320235
float32_t test_vget_lane_f32(float32x2_t a) {
321236
return vget_lane_f32(a, 1);
@@ -326,11 +241,8 @@ float32_t test_vget_lane_f32(float32x2_t a) {
326241
// CIR: {{%.*}} = cir.vec.extract {{%.*}}[[[IDX]] : !s32i] : !cir.vector<!cir.float x 2>
327242

328243
// LLVM: {{.*}}test_vget_lane_f32(<2 x float>{{.*}}[[ARG:%.*]])
329-
// LLVM: [[ARG_SAVE:%.*]] = alloca <2 x float>, i64 1, align 8
330-
// LLVM: store <2 x float> [[ARG]], ptr [[ARG_SAVE]], align 8
331-
// LLVM: [[INTRN_ARG:%.*]] = load <2 x float>, ptr [[ARG_SAVE]], align 8
332-
// LLVM: {{%.*}} = extractelement <2 x float> [[INTRN_ARG]], i32 1
333-
// LLVM: ret float {{%.*}}
244+
// LLVM: [[RES:%.*]] = extractelement <2 x float> [[ARG]], i32 1
245+
// LLVM: ret float [[RES]]
334246

335247
float64_t test_vget_lane_f64(float64x1_t a) {
336248
return vget_lane_f64(a, 0);
@@ -341,11 +253,8 @@ float64_t test_vget_lane_f64(float64x1_t a) {
341253
// CIR: {{%.*}} = cir.vec.extract {{%.*}}[[[IDX]] : !s32i] : !cir.vector<!cir.double x 1>
342254

343255
// LLVM: {{.*}}test_vget_lane_f64(<1 x double>{{.*}}[[ARG:%.*]])
344-
// LLVM: [[ARG_SAVE:%.*]] = alloca <1 x double>, i64 1, align 8
345-
// LLVM: store <1 x double> [[ARG]], ptr [[ARG_SAVE]], align 8
346-
// LLVM: [[INTRN_ARG:%.*]] = load <1 x double>, ptr [[ARG_SAVE]], align 8
347-
// LLVM: {{%.*}} = extractelement <1 x double> [[INTRN_ARG]], i32 0
348-
// LLVM: ret double {{%.*}}
256+
// LLVM: [[RES:%.*]] = extractelement <1 x double> [[ARG]], i32 0
257+
// LLVM: ret double [[RES]]
349258

350259
float32_t test_vgetq_lane_f32(float32x4_t a) {
351260
return vgetq_lane_f32(a, 3);
@@ -356,11 +265,8 @@ float32_t test_vgetq_lane_f32(float32x4_t a) {
356265
// CIR: {{%.*}} = cir.vec.extract {{%.*}}[[[IDX]] : !s32i] : !cir.vector<!cir.float x 4>
357266

358267
// LLVM: {{.*}}test_vgetq_lane_f32(<4 x float>{{.*}}[[ARG:%.*]])
359-
// LLVM: [[ARG_SAVE:%.*]] = alloca <4 x float>, i64 1, align 16
360-
// LLVM: store <4 x float> [[ARG]], ptr [[ARG_SAVE]], align 16
361-
// LLVM: [[INTRN_ARG:%.*]] = load <4 x float>, ptr [[ARG_SAVE]], align 16
362-
// LLVM: {{%.*}} = extractelement <4 x float> [[INTRN_ARG]], i32 3
363-
// LLVM: ret float {{%.*}}
268+
// LLVM: [[RES:%.*]] = extractelement <4 x float> [[ARG]], i32 3
269+
// LLVM: ret float [[RES]]
364270

365271
float64_t test_vgetq_lane_f64(float64x2_t a) {
366272
return vgetq_lane_f64(a, 1);
@@ -371,11 +277,8 @@ float64_t test_vgetq_lane_f64(float64x2_t a) {
371277
// CIR: {{%.*}} = cir.vec.extract {{%.*}}[[[IDX]] : !s32i] : !cir.vector<!cir.double x 2>
372278

373279
// LLVM: {{.*}}test_vgetq_lane_f64(<2 x double>{{.*}}[[ARG:%.*]])
374-
// LLVM: [[ARG_SAVE:%.*]] = alloca <2 x double>, i64 1, align 16
375-
// LLVM: store <2 x double> [[ARG]], ptr [[ARG_SAVE]], align 16
376-
// LLVM: [[INTRN_ARG:%.*]] = load <2 x double>, ptr [[ARG_SAVE]], align 16
377-
// LLVM: {{%.*}} = extractelement <2 x double> [[INTRN_ARG]], i32 1
378-
// LLVM: ret double {{%.*}}
280+
// LLVM: [[RES:%.*]] = extractelement <2 x double> [[ARG]], i32 1
281+
// LLVM: ret double [[RES]]
379282

380283
uint8x8x2_t test_vtrn_u8(uint8x8_t a, uint8x8_t b) {
381284
return vtrn_u8(a, b);

0 commit comments

Comments
 (0)