Lines Matching full:abs
6 declare i32 @abs(i32)
10 ; Test that the abs library call simplifier works correctly.
11 ; abs(x) -> x <s 0 ? -x : x.
15 ; CHECK-NEXT: [[RET:%.*]] = call i32 @llvm.abs.i32(i32 [[X:%.*]], i1 true)
18 %ret = call i32 @abs(i32 %x)
24 ; CHECK-NEXT: [[RET:%.*]] = call i64 @llvm.abs.i64(i64 [[X:%.*]], i1 true)
33 ; CHECK-NEXT: [[RET:%.*]] = call i64 @llvm.abs.i64(i64 [[X:%.*]], i1 true)
40 ; We have a canonical form of abs to make CSE easier.
44 ; CHECK-NEXT: [[ABS:%.*]] = call i8 @llvm.abs.i8(i8 [[X:%.*]], i1 false)
45 ; CHECK-NEXT: ret i8 [[ABS]]
49 %abs = select i1 %cmp, i8 %x, i8 %neg
50 ret i8 %abs
57 ; CHECK-NEXT: [[ABS:%.*]] = call <2 x i8> @llvm.abs.v2i8(<2 x i8> [[X:%.*]], i1 false)
58 ; CHECK-NEXT: ret <2 x i8> [[ABS]]
62 %abs = select <2 x i1> %cmp, <2 x i8> %x, <2 x i8> %neg
63 ret <2 x i8> %abs
70 ; CHECK-NEXT: [[ABS:%.*]] = call <2 x i8> @llvm.abs.v2i8(<2 x i8> [[X:%.*]], i1 false)
71 ; CHECK-NEXT: ret <2 x i8> [[ABS]]
75 %abs = select <2 x i1> %cmp, <2 x i8> %x, <2 x i8> %neg
76 ret <2 x i8> %abs
83 ; CHECK-NEXT: [[ABS:%.*]] = call i8 @llvm.abs.i8(i8 [[X:%.*]], i1 true)
84 ; CHECK-NEXT: ret i8 [[ABS]]
88 %abs = select i1 %cmp, i8 %neg, i8 %x
89 ret i8 %abs
94 ; CHECK-NEXT: [[ABS:%.*]] = call i8 @llvm.abs.i8(i8 [[X:%.*]], i1 false)
95 ; CHECK-NEXT: ret i8 [[ABS]]
99 %abs = select i1 %cmp, i8 %neg, i8 %x
100 ret i8 %abs
105 ; CHECK-NEXT: [[TMP1:%.*]] = call i8 @llvm.abs.i8(i8 [[X:%.*]], i1 false)
106 ; CHECK-NEXT: [[ABS:%.*]] = zext i8 [[TMP1]] to i32
107 ; CHECK-NEXT: ret i32 [[ABS]]
112 %abs = select i1 %cmp, i32 %conv, i32 %neg
113 ret i32 %abs
119 ; CHECK-NEXT: [[ABS:%.*]] = call i32 @llvm.abs.i32(i32 [[T1]], i1 false)
120 ; CHECK-NEXT: ret i32 [[ABS]]
125 %abs = select i1 %cmp, i32 %t1, i32 %t2
126 ret i32 %abs
132 ; CHECK-NEXT: [[ABS:%.*]] = call <2 x i8> @llvm.abs.v2i8(<2 x i8> [[T1]], i1 false)
133 ; CHECK-NEXT: ret <2 x i8> [[ABS]]
139 %abs = select <2 x i1> %cmp, <2 x i8> %t1, <2 x i8> %t2
140 ret <2 x i8> %abs
145 ; CHECK-NEXT: [[ABS:%.*]] = call i32 @llvm.abs.i32(i32 [[A:%.*]], i1 false)
146 ; CHECK-NEXT: ret i32 [[ABS]]
150 %abs = select i1 %cmp, i32 %a, i32 %t
151 ret i32 %abs
158 ; CHECK-NEXT: [[ABS:%.*]] = call i32 @llvm.abs.i32(i32 [[T1]], i1 false)
159 ; CHECK-NEXT: [[ADD:%.*]] = add i32 [[ABS]], [[T2]]
165 %abs = select i1 %cmp, i32 %t1, i32 %t2
166 %add = add i32 %abs, %t2 ; increase use count for %t2.
173 ; CHECK-NEXT: [[ABS:%.*]] = call i32 @llvm.abs.i32(i32 [[T1]], i1 false)
174 ; CHECK-NEXT: ret i32 [[ABS]]
179 %abs = select i1 %cmp, i32 %t1, i32 %t2
180 ret i32 %abs
187 ; CHECK-NEXT: [[TMP1:%.*]] = call i8 @llvm.abs.i8(i8 [[X:%.*]], i1 false)
188 ; CHECK-NEXT: [[ABS:%.*]] = sub i8 0, [[TMP1]]
189 ; CHECK-NEXT: ret i8 [[ABS]]
193 %abs = select i1 %cmp, i8 %neg, i8 %x
194 ret i8 %abs
201 ; CHECK-NEXT: [[TMP1:%.*]] = call <2 x i8> @llvm.abs.v2i8(<2 x i8> [[X:%.*]], i1 false)
202 ; CHECK-NEXT: [[ABS:%.*]] = sub <2 x i8> zeroinitializer, [[TMP1]]
203 ; CHECK-NEXT: ret <2 x i8> [[ABS]]
207 %abs = select <2 x i1> %cmp, <2 x i8> %neg, <2 x i8> %x
208 ret <2 x i8> %abs
215 ; CHECK-NEXT: [[TMP1:%.*]] = call <2 x i8> @llvm.abs.v2i8(<2 x i8> [[X:%.*]], i1 false)
216 ; CHECK-NEXT: [[ABS:%.*]] = sub <2 x i8> zeroinitializer, [[TMP1]]
217 ; CHECK-NEXT: ret <2 x i8> [[ABS]]
221 %abs = select <2 x i1> %cmp, <2 x i8> %neg, <2 x i8> %x
222 ret <2 x i8> %abs
229 ; CHECK-NEXT: [[TMP1:%.*]] = call i8 @llvm.abs.i8(i8 [[X:%.*]], i1 false)
230 ; CHECK-NEXT: [[ABS:%.*]] = sub i8 0, [[TMP1]]
231 ; CHECK-NEXT: ret i8 [[ABS]]
235 %abs = select i1 %cmp, i8 %x, i8 %neg
236 ret i8 %abs
241 ; CHECK-NEXT: [[TMP1:%.*]] = call i8 @llvm.abs.i8(i8 [[X:%.*]], i1 false)
242 ; CHECK-NEXT: [[ABS:%.*]] = sub i8 0, [[TMP1]]
243 ; CHECK-NEXT: ret i8 [[ABS]]
247 %abs = select i1 %cmp, i8 %x, i8 %neg
248 ret i8 %abs
253 ; CHECK-NEXT: [[TMP1:%.*]] = call i8 @llvm.abs.i8(i8 [[X:%.*]], i1 false)
255 ; CHECK-NEXT: [[ABS:%.*]] = sub nsw i32 0, [[TMP2]]
256 ; CHECK-NEXT: ret i32 [[ABS]]
261 %abs = select i1 %cmp, i32 %neg, i32 %conv
262 ret i32 %abs
268 ; CHECK-NEXT: [[TMP1:%.*]] = call i32 @llvm.abs.i32(i32 [[T1]], i1 false)
269 ; CHECK-NEXT: [[ABS:%.*]] = sub i32 0, [[TMP1]]
270 ; CHECK-NEXT: ret i32 [[ABS]]
275 %abs = select i1 %cmp, i32 %t2, i32 %t1
276 ret i32 %abs
282 ; CHECK-NEXT: [[TMP1:%.*]] = call <2 x i8> @llvm.abs.v2i8(<2 x i8> [[T1]], i1 false)
283 ; CHECK-NEXT: [[ABS:%.*]] = sub <2 x i8> zeroinitializer, [[TMP1]]
284 ; CHECK-NEXT: ret <2 x i8> [[ABS]]
289 %abs = select <2 x i1> %cmp, <2 x i8> %t2, <2 x i8> %t1
290 ret <2 x i8> %abs
295 ; CHECK-NEXT: [[TMP1:%.*]] = call i32 @llvm.abs.i32(i32 [[A:%.*]], i1 false)
296 ; CHECK-NEXT: [[ABS:%.*]] = sub i32 0, [[TMP1]]
297 ; CHECK-NEXT: ret i32 [[ABS]]
301 %abs = select i1 %cmp, i32 %t, i32 %a
302 ret i32 %abs
308 ; CHECK-NEXT: [[TMP1:%.*]] = call i32 @llvm.abs.i32(i32 [[T1]], i1 false)
316 %abs = select i1 %cmp, i32 %t2, i32 %t1
317 %add = add i32 %t2, %abs ; increase use count for %t2
324 ; CHECK-NEXT: [[TMP1:%.*]] = call i32 @llvm.abs.i32(i32 [[T1]], i1 false)
325 ; CHECK-NEXT: [[ABS:%.*]] = sub i32 0, [[TMP1]]
326 ; CHECK-NEXT: ret i32 [[ABS]]
331 %abs = select i1 %cmp, i32 %t1, i32 %t2
332 ret i32 %abs
335 ; The following 5 tests use a shift+add+xor to implement abs():
341 ; CHECK-NEXT: [[ABS:%.*]] = call i8 @llvm.abs.i8(i8 [[X:%.*]], i1 false)
342 ; CHECK-NEXT: ret i8 [[ABS]]
346 %abs = xor i8 %add, %signbit
347 ret i8 %abs
352 ; CHECK-NEXT: [[ABS:%.*]] = call i8 @llvm.abs.i8(i8 [[X:%.*]], i1 true)
353 ; CHECK-NEXT: ret i8 [[ABS]]
357 %abs = xor i8 %add, %signbit
358 ret i8 %abs
366 ; CHECK-NEXT: [[ABS:%.*]] = call i8 @llvm.smax.i8(i8 [[X:%.*]], i8 0)
367 ; CHECK-NEXT: ret i8 [[ABS]]
371 %abs = xor i8 %add, %signbit
372 ret i8 %abs
377 ; CHECK-NEXT: [[ABS:%.*]] = call <2 x i8> @llvm.abs.v2i8(<2 x i8> [[X:%.*]], i1 false)
378 ; CHECK-NEXT: ret <2 x i8> [[ABS]]
382 %abs = xor <2 x i8> %signbit, %add
383 ret <2 x i8> %abs
389 ; CHECK-NEXT: [[ABS:%.*]] = call <2 x i8> @llvm.abs.v2i8(<2 x i8> [[Y]], i1 false)
390 ; CHECK-NEXT: ret <2 x i8> [[ABS]]
395 %abs = xor <2 x i8> %signbit, %add
396 ret <2 x i8> %abs
402 ; CHECK-NEXT: [[ABS:%.*]] = call i8 @llvm.abs.i8(i8 [[Y]], i1 false)
403 ; CHECK-NEXT: ret i8 [[ABS]]
408 %abs = xor i8 %add, %signbit
409 ret i8 %abs
421 ; CHECK-NEXT: [[ABS:%.*]] = xor i8 [[ADD]], [[SIGNBIT]]
423 ; CHECK-NEXT: ret i8 [[ABS]]
427 %abs = xor i8 %add, %signbit
429 ret i8 %abs
432 ; There's another way to make abs() using shift, xor, and subtract.
437 ; CHECK-NEXT: [[R:%.*]] = call i8 @llvm.abs.i8(i8 [[X:%.*]], i1 false)
448 ; CHECK-NEXT: [[R:%.*]] = call i8 @llvm.abs.i8(i8 [[X:%.*]], i1 true)
481 ; CHECK-NEXT: [[S:%.*]] = call i8 @llvm.abs.i8(i8 [[X:%.*]], i1 false)
494 ; CHECK-NEXT: [[TMP1:%.*]] = call <2 x i8> @llvm.abs.v2i8(<2 x i8> [[X:%.*]], i1 false)
519 ; CHECK-NEXT: [[M1:%.*]] = call i8 @llvm.abs.i8(i8 [[A]], i1 false)
533 ; CHECK-NEXT: [[TMP1:%.*]] = call i8 @llvm.abs.i8(i8 [[A]], i1 false)
548 ; CHECK-NEXT: [[M1:%.*]] = call i8 @llvm.abs.i8(i8 [[A]], i1 false)
562 ; CHECK-NEXT: [[TMP1:%.*]] = call i8 @llvm.abs.i8(i8 [[A]], i1 false)
580 ; CHECK-NEXT: [[T3:%.*]] = call i64 @llvm.abs.i64(i64 [[T]], i1 true)
594 ; CHECK-NEXT: [[S:%.*]] = call i8 @llvm.abs.i8(i8 [[X]], i1 false)
608 ; CHECK-NEXT: [[S:%.*]] = call i8 @llvm.abs.i8(i8 [[X]], i1 false)
639 ; CHECK-NEXT: [[TMP1:%.*]] = call i8 @llvm.abs.i8(i8 [[X]], i1 false)
654 ; CHECK-NEXT: [[TMP1:%.*]] = call i8 @llvm.abs.i8(i8 [[X]], i1 false)
682 ; TODO: negate-of-abs-diff
699 ; TODO: negate-of-abs-diff
720 ; CHECK-NEXT: [[COND:%.*]] = call i8 @llvm.abs.i8(i8 [[SUB_AB]], i1 true)
737 ; CHECK-NEXT: [[COND:%.*]] = call i8 @llvm.abs.i8(i8 [[SUB_AB]], i1 true)
771 ; CHECK-NEXT: [[COND:%.*]] = call i8 @llvm.abs.i8(i8 [[SUB_AB]], i1 true)
786 ; CHECK-NEXT: [[COND:%.*]] = call i8 @llvm.abs.i8(i8 [[SUB_AB]], i1 true)
803 ; CHECK-NEXT: [[COND:%.*]] = call i8 @llvm.abs.i8(i8 [[SUB_AB]], i1 true)
820 ; CHECK-NEXT: [[COND:%.*]] = call i8 @llvm.abs.i8(i8 [[SUB_AB]], i1 true)
839 ; CHECK-NEXT: [[COND:%.*]] = call i8 @llvm.abs.i8(i8 [[SUB_AB]], i1 true)
902 ; CHECK-NEXT: [[COND:%.*]] = call i32 @llvm.abs.i32(i32 [[SUB_AB]], i1 true)
915 ; CHECK-NEXT: [[COND:%.*]] = call <2 x i8> @llvm.abs.v2i8(<2 x i8> [[SUB_AB]], i1 true)
925 ; TODO: negate-of-abs-diff
944 ; TODO: negate-of-abs-diff, but too many uses?