Skip to content

Commit c7d358d

Browse files
ghehgghehg
committed
resolve merge conflict
1 parent 8532153 commit c7d358d

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
@@ -26,14 +26,8 @@ uint8x8_t test_vset_lane_u8(uint8_t a, uint8x8_t b) {
2626
// CIR: {{%.*}} = cir.vec.insert {{%.*}}, {{%.*}}[[[IDX]] : !s32i] : !cir.vector<!s8i x 8>
2727

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

0 commit comments

Comments
 (0)